dlys(5) [debian man page]

DLYS(5) 							File Formats Manual							   DLYS(5)

NAME

       dlys - format of .dlys files read by the SCALD simulator and timing verifier

DESCRIPTION

       The  SCALD  simulator  and timing verifier can accept information about the actual delays of wires in a circuit.  This delay information is
       described in a .dlys file, which consists of a sequence of records, one for each electrical net.  Each record begins with the  signal  name
       for the net (note that this is the SCALD signal name, i.e, the name given by the user to the entire net, and not usually the name of one of
       the pins in the net), followed by an =, then a comma-separated list of the terminals in the net and their associated delay, with  the  list
       terminated by a semicolon.  The end of the file is marked with a second semicolon.

       The elements of the comma-separated list for each net take the form

	       location [min:max]

       where  location	is  the full hierarchical SCALD name of the physical pin to which the delay is computed, and min and max are the best-case
       and worst-case wire delay in nanoseconds (both are floating-point numbers).  The assumption is that only a single driver exists per net, so
       all  delays  are  computed from this driver.  If a net has multiple drivers, then the interpretation of delays is up to the program reading
       this file (e.g, min delays are taken from the fastest driver, max from the slowest).

       Here is an example .dlys file:

       (APS )ALU STATUS BITS I1<0> =
	  (APS MR 3V6 R1 1P )IN#63[ 0.3 : 0.4 ],
	  (APS APS 4RI RFC RF )OUT[ 0.5 : 0.7 ];
       (APS )ALU STATUS BITS I1<1> =
	  (APS APS 4ALUD DCD )AN#12[ 1.4 : 1.6 ],
	  (APS APS 4ALUD DCD )AN#8[ 1.1 : 1.3 ],
	  (APS APS 4ALUD DCD )AN#9[ 1.1 : 1.3 ],
	  (APS APS 4ALUD DCD )AN#10[ 1.1 : 1.3 ],
	  (APS APS 4ALUD DCD )AN#11[ 1.1 : 1.3 ],
	  (APS MR 3V2 R1 1P )#23[ 0.6 : 0.8 ],
	  (APS MR 3V6 R1 1P )#62[ 0.3 : 0.4 ],
	  (APS APS 4ALUD DCD )[ 0.4 : 0.6 ],
	  (APS APS 4ALUD DCD )#1[ 0.4 : 0.6 ],
	  (APS APS 4ALUD DCD )#2[ 0.4 : 0.6 ],
	  (APS APS 4ALUD DCD )#3[ 0.4 : 0.6 ],
	  (APS APS 4ALUD DCD )#4[ 0.7 : 0.8 ],
	  (APS APS 4ALUD DCD )#5[ 0.7 : 0.8 ];
       ;

       Although it is not good practice, it is possible to omit the actual pin names from the location names and only give the path to	the  part;
       the example above shows several cases where the final pin name is missing.  Since the timing verifier and simulator have the original SCALD
       netlist available, they are usually able to use the signal name to determine the net, and then use the part's path to identify which pin of
       the  net  is  meant.   This  is accurate when a net connects to at most one pin per part; if it connects to more than one pin per part then
       there is ambiguity over which pin is meant.  Usually, though, this ambiguity results in only a small inaccuracy, since the delay to differ-
       ent  pins  on  the  same part is usually similar.  Also, if delay is capacitive, the delay to all pins in a net will be the same anyway, so
       there is no inaccuracy.

SEE ALSO

       ext2dlys(1), ext(5), sim(5)

BUGS

       There should be some way to specify which pins are drivers and which are receivers in a net.

       The ability to omit pin names is dangerous; although it usually works it can introduce large inaccuracies when the parts are large compared
       to the sizes of the wires used to connect them, as might be the case on a silicon PCB.

																	   DLYS(5)

GPIO(3) 						   BSD Library Functions Manual 						   GPIO(3)

NAME

     gpio_open, gpio_close -- library to handle GPIO pins

LIBRARY

     library ``libgpio''

SYNOPSIS

     #include <libgpio.h>

     gpio_handle_t
     gpio_open(unsigned int unit);

     gpio_handle_t
     gpio_open_device(const char *device);

     void
     gpio_close(gpio_handle_t handle);

     int
     gpio_pin_list(gpio_handle_t handle, gpio_config_t **pcfgs);

     int
     gpio_pin_config(gpio_handle_t handle, gpio_config *cfg);

     int
     gpio_pin_set_flags(gpio_handle_t handle, gpio_config_t *cfg);

     gpio_value_t
     gpio_pin_get(gpio_handle_t handle, gpio_pin_t pin);

     int
     gpio_pin_set(gpio_handle_t handle, gpio_pin_t pin, gpio_value_t value);

     int
     gpio_pin_toggle(gpio_handle_t handle, gpio_pin_t pin);

     int
     gpio_pin_low(gpio_handle_t handle, gpio_pin_t pin);

     int
     gpio_pin_high(gpio_handle_t handle, gpio_pin_t pin);

     int
     gpio_pin_input(gpio_handle_t handle, gpio_pin_t pin);

     int
     gpio_pin_output(gpio_handle_t handle, gpio_pin_t pin);

     int
     gpio_pin_opendrain(gpio_handle_t handle, gpio_pin_t pin);

     int
     gpio_pin_pushpull(gpio_handle_t handle, gpio_pin_t pin);

     int
     gpio_pin_tristate(gpio_handle_t handle, gpio_pin_t pin);

     int
     gpio_pin_pullup(gpio_handle_t handle, gpio_pin_t pin);

     int
     gpio_pin_pulldown(gpio_handle_t handle, gpio_pin_t pin);

     int
     gpio_pin_invin(gpio_handle_t handle, gpio_pin_t pin);

     int
     gpio_pin_invout(gpio_handle_t handle, gpio_pin_t pin);

     int
     gpio_pin_pulsate(gpio_handle_t handle, gpio_pin_t pin);

DESCRIPTION

     The libgpio library provides an interface to configure GPIO pins.	The library operates with a gpio_handle_t opaque type which can be created
     with gpio_open() or gpio_open_device().  When no more GPIO operations are needed, this handle can be destroyed with gpio_close().

     To get a list of all available pins, one can call gpio_pin_list().  This function takes a pointer to a gpio_config_t which is dynamically
     allocated.  This pointer should be freed with free(3) when it's no longer necessary.

     The function gpio_pin_config() retrieves the current configuration of a pin.  The pin number should be passed in via the g_pin variable which
     is part of the gpio_config_t structure.

     The function gpio_pin_set_flags() configures a pin with the flags passed in by the gpio_config_t structure.  The pin number should also be
     passed in through the g_pin variable.  All other structure members will be ignored by this function.  The list of flags can be found in
     /usr/include/sys/gpio.h.

     The get or set the state of a GPIO pin, the functions gpio_pin_get() and gpio_pin_set() are available, respectively.  To toggle the state,
     use gpio_pin_toggle().

     The functions gpio_pin_low() and gpio_pin_high() are wrappers around gpio_pin_set().

     The functions gpio_pin_input(), gpio_pin_output(), gpio_pin_opendrain(), gpio_pin_pushpull(), gpio_pin_tristate(), gpio_pin_pullup(),
     gpio_pin_pulldown(), gpio_pin_invin(), gpio_pin_invout() and gpio_pin_pulsate() are wrappers around gpio_pin_set_flags().

EXAMPLES

     The following example shows how to configure pin 16 as output and then drive it high:

     #include <err.h>
     #include <libgpio.h>

     gpio_handle_t handle;

     handle = gpio_open(0);
     if (handle == GPIO_HANDLE_INVALID)
	     err(1, "gpio_open failed");
     gpio_pin_output(handle, 16);
     gpio_pin_high(handle, 16);
     gpio_close(handle);

     The following example shows how to get a configuration of a pin:

     gpio_config_t cfg;

     cfg.g_pin = 32;
     gpio_pin_config(handle, &cfg);

     The structure will contain the name of the pin and its flags.

SEE ALSO

     gpiobus(4), gpioctl(8)

HISTORY

     The libgpio library first appeared in FreeBSD 11.0.

AUTHORS

     The libgpio library was implemented by Rui Paulo <rpaulo@FreeBSD.org>.

BSD
								 November 17, 2014							       BSD