timing.cli.io Namespace Reference

Functions
	io (obj, device)
	reset (ctx, obj, soft, clocksource, forcepllcfg)
	freq (obj)
	status (ctx, obj, verbose)
	clkstatus (ctx, obj, verbose)
	dacsetup (ctx, obj, value)
	sfpstatus (ctx, obj, sfp_id)
	switchsfptx (ctx, obj, sfp_id, on)
	switchsfpmux (obj, mux)
	print_hardware_info (ctx, obj)
	temp (obj)

Function Documentation

clkstatus()

timing.cli.io.clkstatus	(		ctx,
			obj,
			verbose )

Definition at line 191 of file io.py.

def clkstatus(ctx, obj, verbose):
 
    lDevice = obj.mDevice
    lDesignType = obj.mDesignType
    lIO = lDevice.getNode('io')
    lBoardType = obj.mBoardType
    
    ctx.invoke(status)
 
    echo()
    ctx.invoke(freq)
    echo()
 
    if lBoardType in kLibrarySupportedBoards:    
        echo(lIO.get_pll_status())
    else:
        secho("Board {} not supported by timing library".format(lBoardType), fg='yellow')
        # do freq measurement here
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@io.command('dac-setup')
@click.argument('value', type=click.IntRange(0,0xffff))
@click.pass_obj
@click.pass_context

dacsetup()

timing.cli.io.dacsetup	(		ctx,
			obj,
			value )

Definition at line 216 of file io.py.

def dacsetup(ctx, obj, value):
 
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
    lIO = lDevice.getNode('io')
 
    if lBoardType == kBoardTLU:
        lIO.configure_dac(0,value)
        lIO.configure_dac(1,value)
        secho("DAC1 and DAC2 set to " + hex(value), fg='cyan')
    else:
        secho("DAC setup only supported for TLU")
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@io.command('sfp-status', short_help="Read SFP parameters.")
@click.pass_obj
@click.pass_context
@click.option('--sfp-id', 'sfp_id', required=False, type=click.IntRange(0, 8), help='SFP id to query.')

freq()

timing.cli.io.freq

(

obj

)

Definition at line 148 of file io.py.

def freq(obj):
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
    lIO = lDevice.getNode('io')
    
    secho("PLL Clock frequency measurement:", fg='cyan')
    
    if lBoardType in kLibrarySupportedBoards:    
        echo(lIO.get_clock_frequencies_table())
    else:
        secho("Board {} not supported by timing library".format(lBoardType), fg='yellow')
        # do freq measurement here
        if lBoardType == kBoardMIB:
            
            # MIB clock freq meas reg ops here
 
            secho('MIB clock freqs', fg='green')
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@io.command('status')
@click.pass_obj
@click.pass_context
@click.option('-v', 'verbose', is_flag=True)

io()

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

Timing master commands.

DEVICE: uhal device identifier

Definition at line 38 of file io.py.

def io(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'))
    lTopDesign = lDevice.getNode('')
    lBoardInfo = toolbox.readSubNodes(lDevice.getNode('io.config'), False)
    lDevice.dispatch()
 
    if lBoardInfo['board_type'].value() in kLibrarySupportedBoards and lBoardInfo['design_type'].value() in kLibrarySupportedDesigns:
        lTopDesign.validate_firmware_version()
 
    echo("Design '{}' on board '{}' on carrier '{}' with frequency {} MHz".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'),
        style(str(lBoardInfo['clock_frequency'].value()/1e6), fg='blue')
    ))
 
    obj.mDevice = lDevice
    
    obj.mBoardType = lBoardInfo['board_type'].value()
    obj.mCarrierType = lBoardInfo['carrier_type'].value()
    obj.mDesignType = lBoardInfo['design_type'].value()
    
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@io.command('reset', short_help="Perform a hard reset on the timing master.")
@click.option('--soft', '-s', is_flag=True, default=False, help='Soft reset i.e. skip the clock chip configuration.')
@click.option('--clock-source', 'clocksource', type=click.Choice(ClockSource.__members__.keys()), help='Manually specify clock source, free-running, upstream, etc..')
@click.option('--force-pll-cfg', 'forcepllcfg', type=click.Path(exists=True), help='Manually specify clock config file' )
@click.pass_obj
@click.pass_context

print_hardware_info()

timing.cli.io.print_hardware_info	(		ctx,
			obj )

Definition at line 332 of file io.py.

def print_hardware_info(ctx, obj):
 
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
    lIO = lDevice.getNode('io')
 
    if lBoardType in kLibrarySupportedBoards:
        try:
            echo(lIO.get_hardware_info())
        except:
            secho("Failed to retrieve hardware information! I2C issue? Initial board reset needed?", fg='yellow')
            e = sys.exc_info()[0]
            secho("Error: {}".format(e), fg='red')
    else:
        secho("Board {} not supported by timing library".format(lBoardType), fg='yellow')
        # do status printing here
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@io.command('temp', short_help="Read board temperature")
@click.pass_obj

reset()

timing.cli.io.reset	(		ctx,
			obj,
			soft,
			clocksource,
			forcepllcfg )

Perform a hard reset on a timing board, including

\b
- ipbus registers
- i2c buses
- pll and pll configuration

Definition at line 78 of file io.py.

def reset(ctx, obj, soft, clocksource, forcepllcfg):
    '''
    Perform a hard reset on a timing board, including
 
    \b
    - ipbus registers
    - i2c buses
    - pll and pll configuration
    '''
 
    echo('Resetting ' + click.style(obj.mDevice.id(), fg='blue'))
 
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
    lDesignType = obj.mDesignType
 
    lIO = lDevice.getNode('io')
 
    if lBoardType in kLibrarySupportedBoards:
 
        if soft:
            lIO.soft_reset()
            return
 
        if forcepllcfg is not None:
            if clocksource is not None:
                secho("You specified both a clock source for automatic clock config file look-up, and an explicit clock config file. Explicit clock config file will take precedence.", fg='yellow')
 
            lIO.reset(forcepllcfg)
        else:
            lClockSource = None
            if clocksource is None:
                if lDesignType in [kDesignMaster, kDesignBoreas, kDesignOuroboros, kDesignOuroborosSim]:
                    lClockSource=kFreeRun
                elif lDesignType in [kDesignEndpoint, kDesignChronos, kDesignHades, kDesignCharon]:
                    lClockSource=kInput1
                elif lDesignType == kDesignFanout:
                    if lBoardType == kBoardFIB: #technically only fib v2
                        lClockSource=kInput0
                    elif lBoardType == kBoardPC059:
                        lClockSource=kInput1
                elif lDesignType in [kDesignGaia, kDesignKerberos]:
                    lClockSource=kInput0
 
                if lClockSource is None:
                    secho(f"Unable to match a default clock source for {kDesignNameMap[lDesignType]} on {kBoardNameMap[lBoardType]}\nReset failed!".format(), fg='red')
                    return
                else:
                    secho(f"Default clock config selected for {kDesignNameMap[lDesignType]} on {kBoardNameMap[lBoardType]} is: {lClockSource}", fg='yellow')
            else:
                lClockSource=ClockSource.__members__[clocksource]
 
            # lIO.reset_pll()
            # lIO.getNode("csr.ctrl.i2c_sw_rst").write(0x0)
            # lIO.getNode("csr.ctrl.i2c_exten_rst").write(0x0)
            # lIO.getNode("csr.ctrl.clk_gen_rst").write(0x0)
 
            # lIO.getNode("csr.ctrl.i2c_sw_rst").write(0x1)
            # lIO.getNode("csr.ctrl.i2c_exten_rst").write(0x1)
            # lIO.getNode("csr.ctrl.clk_gen_rst").write(0x1)
            lIO.reset(lClockSource)
        ctx.invoke(clkstatus)
    else:
        secho("Board identifier {} not supported by timing library".format(lBoardType), fg='yellow')
        # board not supported by library, do reset here
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@io.command('freq', short_help="Measure some frequencies.")
@click.pass_obj

sfpstatus()

timing.cli.io.sfpstatus	(		ctx,
			obj,
			sfp_id )

Read SFP status

Definition at line 235 of file io.py.

def sfpstatus(ctx, obj, sfp_id):
    '''
    Read SFP status
    '''
 
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
    lCarrierType = obj.mCarrierType
    lDesignType = obj.mDesignType
 
    lIO = lDevice.getNode('io')
    
    
    if lBoardType in kLibrarySupportedBoards:
        ctx.invoke(print_hardware_info)
        if sfp_id is not None:
            echo(lIO.get_sfp_status(sfp_id))
        else:
            if lBoardType in [kBoardFMC, kBoardTLU, kBoardPC069]:
                echo(lIO.get_sfp_status(0))
            elif lBoardType in [ kBoardPC059, kBoardFIB, kBoardMIB, kBoardGIB ]:
                # PC059 sfp id 0 is upstream sfp
                if lBoardType == kBoardPC059:
                    lSFPIDRange = 9
                elif lBoardType == kBoardFIB:
                    lSFPIDRange = 8
                elif lBoardType == kBoardMIB:
                    lSFPIDRange = 3
                elif lBoardType == kBoardGIB:
                    lSFPIDRange = 6
                for i in range(lSFPIDRange):
                    try:
                        echo(lIO.get_sfp_status(i))
                        #echo()
                    except:
                        secho(f"SFP {i} status gather failed\n", fg='red')
                        pass
            else:
                secho(f"I don't know how many SFPs there are for board: {timing.common.definitions.BoardType(lBoardType)}\n", fg='red')
 
    else:
        secho("Board {} not supported by timing library".format(lBoardType), fg='yellow')
        # do sfp status here
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@io.command('switch-sfp-tx', short_help="Control sfp tx")
@click.pass_obj
@click.pass_context
@click.option('--sfp-id', 'sfp_id', required=False, type=click.IntRange(0, 8), help='SFP id to query.')
@click.option('--on/--off', default=False, help='enable/disable tx; default: FALSE')

status()

timing.cli.io.status	(		ctx,
			obj,
			verbose )

Definition at line 172 of file io.py.

def status(ctx, obj, verbose):
 
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
    lIO = lDevice.getNode('io')
 
    if lBoardType in kLibrarySupportedBoards:
        ctx.invoke(print_hardware_info)
        echo(lIO.get_status())
    else:
        secho("Board {} not supported by timing library".format(lBoardType), fg='yellow')
        # do status printing here
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@io.command('clk-status')
@click.pass_obj
@click.pass_context
@click.option('-v', 'verbose', is_flag=True)

switchsfpmux()

timing.cli.io.switchsfpmux	(		obj,
			mux )

Definition at line 313 of file io.py.

def switchsfpmux(obj, mux):
    
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
    lIO = lDevice.getNode('io')
 
    if lBoardType in [kBoardPC059]:
        
        echo("Setting sfp mux channel: {}".format(mux))
        lIO.switch_sfp_mux_channel(mux)
 
    else:
        raise RuntimeError('Board {} does not have a sfp mux!'.format(kBoardNameMap[lBoardType]))
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@io.command('print-hardware-info')
@click.pass_obj
@click.pass_context

switchsfptx()

timing.cli.io.switchsfptx	(		ctx,
			obj,
			sfp_id,
			on )

Toggle SFP tx disable reg (if supported)

Definition at line 286 of file io.py.

def switchsfptx(ctx, obj, sfp_id, on):
    '''
    Toggle SFP tx disable reg (if supported)
    '''
 
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
    lCarrierType = obj.mCarrierType
    lDesignType = obj.mDesignType
 
    lIO = lDevice.getNode('io') 
 
    if lBoardType in kLibrarySupportedBoards:
        ctx.invoke(print_hardware_info)
        lSFP=sfp_id
        if sfp_id is None:
            lSFP=0
        lIO.switch_sfp_tx(lSFP, on)
    else:
        secho("Board {} not supported by timing library".format(lBoardType), fg='yellow')
        # do sfp switch here
# ------------------------------------------------------------------------------
 
# ------------------------------------------------------------------------------
@io.command('switch-sfp-mux', short_help="Switch sfp mux")
@click.argument('mux', type=int)
@click.pass_obj

temp()

timing.cli.io.temp

(

obj

)

Definition at line 353 of file io.py.

def temp(obj):
 
    lDevice = obj.mDevice
    lBoardType = obj.mBoardType
    lIO = lDevice.getNode('io')
 
    if lBoardType in [kBoardFIB]: # strictly only FIB v2
        temp = lIO.read_board_temperature()
        echo(f"Board temp: {temp} [C]")
    else:
        raise RuntimeError('Board {} does not have a temp reading!'.format(kBoardNameMap[lBoardType]))
# ------------------------------------------------------------------------------