URL https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [packages/] [hal/] [synth/] [arch/] [current/] [doc/] [synth.sgml] - Blame information for rev 838

Go to most recent revision | Details | Compare with Previous | View Log


 

 






























 

 
eCos Synthetic Target
 

 

  
    Overview
  
  
    The eCos synthetic target
    Overview
  
 
  Description
    
Usually eCos runs on either a custom piece of hardware, specially
designed to meet the needs of a specific application, or on a
development board of some sort that is available before the final
hardware. Such boards have a number of things in common:
    
    
      
Obviously there has to be at least one processor to do the work. Often
this will be a 32-bit processor, but it can be smaller or larger.
Processor speed will vary widely, depending on the expected needs of
the application. However the exact processor being used tends not to
matter very much for most of the development process: the use of
languages such as C or C++ means that the compiler will handle those
details.
      
      
There needs to be memory for code and for data. A typical system will
have two different types of memory. There will be some non-volatile
memory such as flash, EPROM or masked ROM. There will also be some
volatile memory such as DRAM or SRAM. Often the code for the final
application will reside in the non-volatile memory and all of the RAM
will be available for data. However updating non-volatile memory
requires a non-trivial amount of effort, so for much of the
development process it is more convenient to burn suitable firmware,
for example RedBoot, into the non-volatile memory and then use that to
load the application being debugged into RAM, alongside the
application data and a small area reserved for use by the firmware.
      
      
The platform must provide certain mimimal I/O facilities. Most eCos
configurations require a clock signal of some sort. There must also be
some way of outputting diagnostics to the user, often but not always
via a serial port. Unless special debug hardware is being used, source
level debugging will require bidirectional communication between a
host machine and the target hardware, usually via a serial port or an
ethernet device.
      
      
All the above is not actually very useful yet because there is no way
for the embedded device to interact with the rest of the world, except
by generating diagnostics. Therefore an embedded device will have
additional I/O hardware. This may be fairly standard hardware such as
an ethernet or USB interface, or special hardware designed
specifically for the intended application, or quite often some
combination. Standard hardware such as ethernet or USB may be
supported by eCos device drivers and protocol stacks, whereas the
special hardware will be driven directly by application code.
      
    
    
Much of the above can be emulated on a typical PC running Linux.
Instead of running the embedded application being developed on a
target board of some sort, it can be run as a Linux process. The
processor will be the PC's own processor, for example an x86, and the
memory will be the process' address space. Some I/O facilities can be
emulated directly through system calls. For example clock hardware can
be emulated by setting up a SIGALRM signal, which
will cause the process to be interrupted at regular intervals. This
emulation of real hardware will not be particularly accurate, the
number of cpu cycles available to the eCos application between clock
ticks will vary widely depending on what else is running on the PC,
but for much development work it will be good enough.
    
    
Other I/O facilities are provided through an I/O auxiliary process,
ecosynth, that gets spawned by the eCos application during startup.
When an eCos device driver wants to perform some I/O operation, for
example send out an ethernet packet, it sends a request to the I/O
auxiliary. That is an ordinary Linux application so it has ready
access to all normal Linux I/O facilities. To emulate a device
interrupt the I/O auxiliary can raise a SIGIO
signal within the eCos application. The HAL's interrupt subsystem
installs a signal handler for this, which will then invoke the
standard eCos ISR/DSR mechanisms. The I/O auxiliary is based around
Tcl scripting, making it easy to extend and customize. It should be
possible to configure the synthetic target so that its I/O
functionality is similar to what will be available on the final target
hardware for the application being developed.
    
    
      
        
          
        
      
    
    
A key requirement for synthetic target code is that the embedded
application must not be linked with any of the standard Linux
libraries such as the GNU C library: that would lead to a confusing
situation where both eCos and the Linux libraries attempted to provide
functions such as printf. Instead the synthetic
target support must be implemented directly on top of the Linux
kernels' system call interface. For example, the kernel provides a
system call for write operations. The actual function
write is implemented in the system's C library,
but all it does is move its arguments on to the stack or into certain
registers and then execute a special trap instruction such as
int 0x80. When this instruction is executed
control transfers into the kernel, which will validate the arguments
and perform the appropriate operation. Now, a synthetic target
application cannot be linked with the system's C library. Instead it
contains a function cyg_hal_sys_write which, like
the C library's write function, pushes its
arguments on to the stack and executes the trap instruction. The Linux
kernel cannot tell the difference, so it will perform the I/O
operation requested by the synthetic target. With appropriate
knowledge of what system calls are available, this makes it possible
to emulate the required I/O facilities. For example, spawning the
ecosynth I/O auxiliary involves system calls
cyg_hal_sys_fork and
cyg_hal_sys_execve, and sending a request to the
auxiliary uses cyg_hal_sys_write.
    
    
In many ways developing for the synthetic target is no different from
developing for real embedded targets. eCos must be configured
appropriately: selecting a suitable target such as
i386linux will cause the configuration system
to load the appropriate packages for this hardware; this includes an
architectural HAL package and a platform-specific package; the
architectural package contains generic code applicable to all Linux
platforms, whereas the platform package is for specific Linux
implementations such as the x86 version and contains any
processor-specific code. Selecting this target will also bring in some
device driver packages. Other aspects of the configuration such as
which API's are supported are determined by the template, by adding
and removing packages, and by fine-grained configuration.
    
    
In other ways developing for the synthetic target can be much easier
than developing for a real embedded target. For example there is no
need to worry about building and installing suitable firmware on the
target hardware, and then downloading and debugging the actual
application over a serial line or a similar connection. Instead an
eCos application built for the synthetic target is mostly
indistinguishable from an ordinary Linux program. It can be run simply
by typing the name of the executable file at a shell prompt.
Alternatively you can debug the application using whichever version of
gdb is provided by your Linux distribution. There is no need to build
or install special toolchains. Essentially using the synthetic target
means that the various problems associated with real embedded hardware
can be bypassed for much of the development process.
    
    
The eCos synthetic target provides emulation, not simulation. It is
possible to run eCos in suitable architectural simulators but that
involves a rather different approach to software development. For
example, when running eCos on the psim PowerPC simulator you need
appropriate cross-compilation tools that allow you to build PowerPC
executables. These are then loaded into the simulator which interprets
every instruction and attempts to simulate what would happen if the
application were running on real hardware. This involves a lot of
processing overhead, but depending on the functionality provided by
the simulator it can give very accurate results. When developing for
the synthetic target the executable is compiled for the PC's own
processor and will be executed at full speed, with no need for a
simulator or special tools. This will be much faster and somewhat
simpler than using an architectural simulator, but no attempt is made
to accurately match the behaviour of a real embedded target.
    
  

 


 

  
    Installation
  
  
    Installation
    Preparing to use the synthetic target
  
 
  Host-side Software
    
To get the full functionality of the synthetic target, users must
build and install the I/O auxiliary ecosynth and various support
files. It is possible to develop applications for the synthetic target
without the auxiliary, but only limited I/O facilities will be
available. The relevant code resides in the 
class="directory">host subdirectory of the synthetic target
architectural HAL package, and building it involves the standard
configure, make, and
make install steps.
    
    
There are two main ways of building the host-side software. It is
possible to build both the generic host-side software and all
package-specific host-side software, including the I/O auxiliary. in a
single build tree. This involves using the
configure script at the toplevel of the eCos
repository, which will automatically search the 
class="directory">packages hierarchy for host-side
software. For more information on this, see the
README.host file at the top of the repository.
Note that if you have an existing build tree which does not include
the synthetic target architectural HAL package then it will be
necessary to rerun the toplevel configure script: the search for
appropriate packages happens at configure time.
    
    
The alternative is to build just the host-side for this package.
This involves creating a suitable build directory and running the
configure script. Note that building directly in
the source tree is not allowed.
    
    
$ cd <somewhere suitable>
$ mkdir synth_build
$ cd synth_build
$ <repo<>/packages/hal/synth/arch/<version>/host/configure <options>
$ make
$ make install

    
The code makes extensive use of Tcl/TK and requires version 8.3 or
later. This is checked by the configure script. By
default it will use the system's Tcl installation in 
class="directory">/usr. If a different, more recent Tcl
installation should be used then its location can be specified using
the options --with-tcl=<path>,
--with-tcl-header=<path> and
--with-tcl-lib=<path>. For more information on these options
see the README.host file at the toplevel of the
eCos repository.
    
    
Some users may also want to specify the install location using a
--prefix=<path> option. The default install
location is /usr/local. It is
essential that the bin
subdirectory of the install location is on the user's search
PATH, otherwise the eCos application will be unable to
locate and execute the I/O auxiliary ecosynth.
    
    
Because ecosynth is run automatically by an eCos application rather
than explicitly by the user, it is not installed in the 
class="directory">bin subdirectory itself. Instead it is
installed below libexec,
together with various support files such as images. At configure time
it is usually possible to specify an alternative location for
libexec using
--exec-prefix=<path> or
--libexecdir=<path>. These options should not
be used for this package because the eCos application is built
completely separately and does not know how the host-side was
configured.
    
  
 
  Toolchain
    
When developing eCos applications for a normal embedded target it is
necessary to use a suitable cross-compiler and related tools such as
the linker. Developing for the synthetic target is easier because you
can just use the standard GNU tools (gcc, g++, ld, …) which
were provided with your Linux distribution, or which you used to build
your own Linux setup. Any reasonably recent version of the tools, for
example gcc 2.96(Red Hat) as shipped with Red Hat Linux 7, should be
sufficient.
    
    
There is one important limitation when using these tools: current gdb
will not support debugging of eCos threads on the synthetic target. As
far as gdb is concerned a synthetic target application is
indistinguishable from a normal Linux application, so it assumes that
any threads will be created by calls to the Linux
pthread_create function provided by the C
library. Obviously this is not the case since the application is never
linked with that library. Therefore gdb never notices the eCos thread
mechanisms and assumes the application is single-threaded. Fixing this
is possible but would involve non-trivial changes to gdb.
    
    
Theoretically it is possible to develop synthetic target applications
on, for example, a PC running Windows and then run the resulting
executables on another machine that runs Linux. This is rarely useful:
if a Linux machine is available then usually that machine will also be
used for building ecos and the application. However, if for some
reason it is necessary or desirable to build on another machine then
this requires a suitable cross-compiler and related tools. If the
application will be running on a typical PC with an x86 processor then
a suitable configure triplet would be
i686-pc-linux-gnu. The installation
instructions for the various GNU tools should be consulted for further
information.
    
  
 
  Hardware Preparation
    
Preparing a real embedded target for eCos development can be tricky.
Often the first step is to install suitable firmware, usually RedBoot.
This means creating and building a special configuration for eCos with
the RedBoot template, then somehow updating the target's flash chips
with the resulting RedBoot image. Typically it will also be necessary
to get a working serial connection, and possibly set up ethernet as
well. Although usually none of the individual steps are particularly
complicated, there are plenty of ways in which things can go wrong and
it can be hard to figure out what is actually happening. Of course
some board manufacturers make life easier for their developers by
shipping hardware with RedBoot preinstalled, but even then it is still
necessary to set up communication between host and target.
    
    
None of this is applicable to the synthetic target. Instead you can
just build a normal eCos configuration, link your application with the
resulting libraries, and you end up with an executable that you can
run directly on your Linux machine or via gdb. A useful side effect of
this is that application development can start before any real
embedded hardware is actually available.
    
    
Typically the memory map for a synthetic target application will be
set up such that there is a read-only ROM region containing all the
code and constant data, and a read-write RAM region for the data. The
default locations and sizes of these regions depend on the specific
platform being used for development. Note that the application always
executes out of ROM: on a real embedded target much of the development
would involve running RedBoot firmware there, with application code
and data loaded into RAM; usually this would change for the final
system; the firmware would be replaced by the eCos application itself,
configured for ROM bootstrap, and it would perform the appropriate
hardware initialization. Therefore the synthetic target actually
emulates the behaviour of a final system, not of a development
environment. In practice this is rarely significant, although having
the code in read-only memory can help catch some problems in
application code.
    
  
 

 


 

  
    Running a Synthetic Target Application
  
  
    Execution
    Arguments and configuration files
  
 
  Description
    
The procedure for configuring and building eCos and an application for
the synthetic target is the same as for any other eCos target. Once an
executable has been built it can be run like any Linux program, for
example from a shell prompt,
    
    
$ ecos_hello <options>

    
or using gdb:
    
    
$ gdb --nw --quiet --args ecos_hello <options>
(gdb) run
Starting program: ecos_hello <options>

    
By default use of the I/O auxiliary is disabled. If its I/O facilities
are required then the option --io must be used.
    
    
In future the default behaviour may change, with the I/O auxiliary
being started by default. The option --nio can be
used to prevent the auxiliary from being run.
    
  
 
  Command-line Arguments
    
The syntax for running a synthetic target application is:
    
    
$ <ecos_app> [options] [-- [app_options]]

    
Command line options up to the -- are passed on to
the I/O auxiliary. Subsequent arguments are not passed on to the
auxiliary, and hence can be used by the eCos application itself. The
full set of arguments can be accessed through the variables
cyg_hal_sys_argc and
cyg_hal_sys_argv.
    
    
The following options are accepted as standard:
    
    
      
        --io
         
This option causes the eCos application to spawn the I/O auxiliary
during HAL initialization. Without this option only limited I/O will
be available.
         
      
      
        --nio
         
This option prevents the eCos application from spawning the I/O
auxiliary. In the current version of the software this is the default.
         
      
      
        -nw, --no-windows
         
The I/O auxiliary can either provide a graphical user interface, or it
can run in a text-only mode. The default is to provide the graphical
interface, but this can be disabled with -nw.
Emulation of some devices, for example buttons connected to digital
inputs, requires the graphical interface.
         
      
      
        -w, --windows
         
The -w causes the I/O auxiliary to provide a
graphical user interface. This is the default.
         
      
      
        -v, --version
         
The -v option can be used to determine the version of
the I/O auxiliary being used and where it has been installed. Both the
auxiliary and the eCos application will exit immediately.
         
      
      
        -h, --help
         
-h causes the I/O auxiliary to list all accepted
command-line arguments. This happens after all devices have been
initialized, since the host-side support for some of the devices may
extend the list of recognised options. After this both the auxiliary
and the eCos application will exit immediately. This option implies
-nw.
         
      
      
        -k, --keep-going
         
If an error occurs in the I/O auxiliary while reading in any of the
configuration files or initializing devices, by default both the
auxiliary and the eCos application will exit. The -k
option can be used to make the auxiliary continue in spite of errors,
although obviously it may not be fully functional.
         
      
      
        -nr, --no-rc
         
Normally the auxiliary processes two 
linkend="synth-running-user-config">user configuration files
during startup: initrc.tcl and
mainrc.tcl. This can be suppressed using the
-nr option.
         
      
      
        -x, --exit
         
When providing a graphical user interface the I/O auxiliary will
normally continue running even after the eCos application has exited.
This allows the user to take actions such as saving the current
contents of the main text window. If run with -x then
the auxiliary will exit as soon the application exits.
         
      
      
        -nx, --no-exit
         
When the graphical user interface is disabled with
-nw the I/O auxiliary will normally exit immediately
when the eCos application exits. Without the graphical frontend there
is usually no way for the user to interact directly with the
auxiliary, so there is no point in continuing to run once the eCos
application will no longer request any I/O operations. Specifying the
-nx option causes the auxiliary to continue running
even after the application has exited.
         
      
      
        -V, --verbose
         
This option causes the I/O auxiliary to output some additional
information, especially during initialization.
         
      
      
        -l <file>, --logfile <file>
         
Much of the output of the eCos application and the I/O auxiliary is
simple text, for example resulting from eCos
printf or diag_printf calls.
When running in graphical mode this output goes to a central text
window, and can be saved to a file or edited via menus. The
-l can be used to automatically generate an
additional logfile containing all the text. If graphical
mode is disabled then by default all the text just goes to the current
standard output. Specifying -l causes most of the
text to go into a logfile instead, although some messages such as
errors generated by the auxiliary itself will still go to stdout as
well.
         
      
      
        -t <file>, --target <file>
         
During initialization the I/O auxiliary reads in a target definition
file. This file holds information such as which Linux devices should
be used to emulate the various eCos devices. The -t
option can be used to specify which target definition should be used
for the current run, defaulting to default.tdf.
It is not necessary to include the .tdf suffix,
this will be appended automatically if necessary.
         
      
      
        -geometry <geometry>
         
This option can be used to control the size and position of the main
window, as per X conventions.
         
      
    
    
The I/O auxiliary loads support for the various devices dynamically
and some devices may accept additional command line arguments. Details
of these can be obtained using the -h option or by
consulting the device-specific documentation. If an unrecognised
command line argument is used then a warning will be issued.
    
  
 
  The Target Definition File
    
The eCos application will want to access devices such as
eth0 or /dev/ser0. These need to
be mapped on to Linux devices. For example some users may all traffic
on the eCos /dev/ser0 serial device to go via the
Linux serial device /dev/ttyS1, while ethernet I/O
for the eCos eth0 device should be mapped to the
Linux ethertap device tap3. Some devices may need
additional configuration information, for example to limit the
number of packets that should be buffered within the I/O auxiliary.
The target definition file provides all this information.
    
    
By default the I/O auxiliary will look for a file
default.tdf. An alternative target definition can
be specified on the command line using -t, for
example:
    
    
$ bridge_app --io -t twineth

    
A .tdf suffix will be appended automatically if
necessary. If a relative pathname is used then the I/O auxiliary will
search for the target definition file in the current directory, then
in ~/.ecos/synth/, and finally
in its install location.
    
    
A typical target definition file might look like this:
    
    
synth_device console {
    # appearance -foreground white -background black
    filter trace {^TRACE:.*} -foreground HotPink1 -hide 1
}
 
synth_device ethernet {
    eth0 real eth1
    eth1 ethertap tap4 00:01:02:03:FE:06
 
    ## Maximum number of packets that should be buffered per interface.
    ## Default 16
    #max_buffer 32
 
    ## Filters for the various recognised protocols.
    ## By default all filters are visible and use standard colours.
    filter ether  -hide 0
    #filter arp    -hide 1
    #filter ipv4   -hide 1
    #filter ipv6   -hide 1
}

    
A target definition file is actually a Tcl script that gets run in the
main interpreter of the I/O auxiliary during initialization. This
provides a lot of flexibility if necessary. For example the script
could open a socket to a resource management server of some sort to
determine which hardware facilities are already in use and adapt
accordingly. Another possibility is to adapt based on 
linkend="synth-new-host-args">command line arguments. Users who
are not familiar with Tcl programming should still be able to edit a
simple target definition file without too much difficulty, using a
mixture of cut'n'paste, commenting or uncommenting various lines, and
making small edits such as changing tap4 to
eth2.
    
    
Each type of device will have its own entry in the target definition
file, taking the form:
    
    
synth_device <device type> {
    <options>
}

    
The documentaton for each synthetic target device should provide
details of the options available for that device, and often a suitable
fragment that can be pasted into a target definition file and edited.
There is no specific set of options that a given device will always
provide. However in practice many devices will use common code
exported by the main I/O auxiliary, or their implementation will
involve some re-use of code for an existing device. Hence certain
types of option are common to many devices.
    
    
A good example of this is filters, which control the appearance of
text output. The above target definition file defines a filter
trace for output from the eCos application. The
regular expression will match output from the infrastructure package's
tracing facilities when CYGDBG_USE_TRACING and
CYGDBG_INFRA_DEBUG_TRACE_ASSERT_SIMPLE are enabled.
With the current settings this output will not be visible by default,
but can be made visible using the menu item System
Filters. If made visible the trace output will appear in
an unusual colour, so users can easily distinguish the trace output
from other text. All filters accept the following options:
    
    
      
         -hide [0|1]
         
This controls whether or not text matching this filter should be
invisible by default or not. At run-time the visibility of each filter
can be controlled using the System Filters
menu item.
         
      
      
         -foreground <colour>
         
This specifies the foreground colour for all text matching this
filter. The colour can be specified using an RGB value such as
#F08010, or a symbolic name such as
"light steel blue". The X11 utility
showrgb can be used to find out
about the available colours.
         
      
      
         -background <colour>
         
This specifies the background colour for all text matching the filter.
As with -foreground the colour can be specified using
a symbolic name or an RGB value.
         
      
    
    
Some devices may create their own subwindows, for example to monitor
ethernet traffic or to provide additional I/O facilities such as
emulated LED's or buttons. Usually the target definition file can be
used to control the layout of
these windows.
    
    
The I/O auxiliary will not normally warn about
synth_device entries in the target definition file
for devices that are not actually needed by the current eCos
application. This makes it easier to use a single file for several
different applications. However it can lead to confusion if an entry
is spelled incorrectly and hence does not actually get used. The
-V command line option can be used to get warnings
about unused device entries in the target definition file.
    
    
If the body of a synth_device command contains an
unrecognised option and the relevant device is in use, the I/O
auxiliary will always issue a warning about such options.
    
  
 
  User Configuration Files
    
During initialization the I/O auxiliary will execute two user
configuration files, initrc.tcl and
mainrc.tcl. It will look for these files in the
directory ~/.ecos/synth/. If
that directory does not yet exist it will be created and populated
with initial dummy files.
    
    
Both of these configuration files are Tcl scripts and will be run in
the main interpreter used by the I/O auxiliary itself. This means that
they have full access to the internals of the auxiliary including the
various Tk widgets, and they can perform file or socket I/O if
desired. The section  contains
information about the facilities available on the host-side for
writing new device drivers, and these can also be used in the
initialization scripts.
    
    
The initrc.tcl script is run before the auxiliary
has processed any requests from the eCos application, and hence before
any devices have been instantiated. At this point the generic
command-line arguments has been processed, the target definition file
has been read in, and the hooks functionality has been initialized. If
running in graphical mode the main window will have been created, but
has been withdrawn from the screen to allow new widgets to be added
without annoying screen flicker. A typical
initrc.tcl script could add some menu or toolbar
options, or install a hook function that will be run when the
eCos application exits.
    
    
The mainrc.tcl script is run after eCos has
performed all its device initialization and after C++ static
constructors have run, and just before the call to
cyg_start which will end up transferring control
to the application itself. A typical mainrc.tcl
script could look at what interrupt vectors have been allocated to
which devices and create a little monitor window that shows interrupt
activity.
    
  
 
  Session Information
    
When running in graphical mode, the I/O auxiliary will read in a file
~/.ecos/synth/guisession containing session
information. This file should not normally be edited manually, instead
it gets updated automatically when the auxiliary exits. The purpose of
this file is to hold configuration options that are manipulated via
the graphical interface, for example which browser should be used to
display online help.
    
    
GUI session functionality is not yet available in the current release.
When that functionality is fully implemented it is possible that some
target definition file options may be removed, to be replaced by
graphical editing via a suitable preferences dialog, with the
current settings saved in the session file.
    
  
 

 


 

  
    The I/O Auxiliary's User Interface
  
  
    User Interface
    Controlling the I/O Auxiliary
  
 
  Description
    
The synthetic target auxiliary is designed to support both extensions
and user customization. Support for the desired devices is dynamically
loaded, and each device can extend the user interface. For example it
is possible for a device to add menu options, place new buttons on the
toolbar, create its own sub-window within the overall layout, or even
create entire new toplevel windows. These subwindows or toplevels
could show graphs of activity such as interrupts or packets being
transferred. They could also allow users to interact with the eCos
application, for example by showing a number of buttons which will be
mapped on to digital inputs in the eCos application. Different
applications will have their own I/O requirements, changing the
host-side support files that get loaded and that may modify the user
interface. The I/O auxiliary also reads in user configuration scripts
which can enhance the interface in the same way. Therefore the exact
user interface will depend on the user and on the eCos application
being run. However the overall layout is likely to remain the same.
    
    
      
        
          
        
      
    
    
The title bar identifies the window as belonging to an eCos synthetic
target application and lists both the application name and its process
id. The latter is especially useful if the application was started
directly from a shell prompt and the user now wants to attach a gdb
session. The window has a conventional menu bar with the usual
entries, plus a toolbar with buttons for common operations such as cut
and paste. Balloon help is supported.
    
    
There is a central text window,
possibly surrounded by various sub-windows for various devices. For
example there could be a row of emulated LED's above the text window,
and monitors of ethernet traffic and interrupt activity on the right.
At the bottom of the window is a status line, including a small
animation that shows whether or not the eCos application is still
running.
    
  
 
  Menus and the Toolbar
    
Usually there will be four menus on the menu bar:
File, Edit,
View and Help.
    
      
      
        
          
        
      
    
    
On the File menu there are three entries related to
saving the current contents of the central text window.
Save is used to save the currently visible
contents of the text window. Any text that is hidden because of
filters will not be written to the savefile. If there has been a
previous Save or Save
As operation then the existing savefile will be re-used,
otherwise the user will be asked to select a suitable file.
Save As also saves just the currently
visible contents but will always prompt the user for a filename.
Save All can be used to save the full
contents of the text window, including any text that is currently
hidden. It will always prompt for a new filename, to avoid confusion
with partial savefiles.
    
    
Usually the eCos application will be run from inside gdb or from a
shell prompt. Killing off the application while it is being debugged
in a gdb session is not a good idea, it would be better to use gdb's
own kill command. Alternatively the eCos
application itself can use the CYG_TEST_EXIT or
cyg_hal_sys_exit functionality. However it is
possible to terminate the application from the I/O auxiliary using
Kill eCos. A clean shutdown will be
attempted, but that can fail if the application is currently halted
inside gdb or if it has crashed completely. As a last resort
SIGKILL will be used.
    
    
When operating in graphical mode the I/O auxiliary will normally
continue to run even after the eCos application has exited. This
allows the user to examine the last few lines of output, and perhaps
perform actions such as saving the output to a file. The
Exit menu item can be used to shut down the
auxiliary. Note that this behaviour can be changed with command line
arguments 
linkend="synth-running-arguments">--exit and

linkend="synth-running-arguments">--no-exit.
    
    
If Exit is used while the eCos application
is still running then the I/O auxiliary will first attempt to
terminate the application cleanly, and then exit.
    
    
      
        
          
        
      
    
    
The Edit menu contains the usual entries for
text manipulation: Cut,
Copy, Paste,
Clear and Select
All. These all operate on the central text window. By
default this window cannot be edited so the cut, paste and clear
operations are disabled. If the user wants to edit the contents of the
text window then the Read Only checkbutton
should be toggled.
    
    
The Preferences menu item brings up a
miscellaneous preferences dialog. One of the preferences relates to
online help: the I/O auxiliary does not currently have a built-in html
viewer; instead it will execute an external browser of some sort. With
the example settings shown, the I/O auxiliary will first attempt to
interact with an existing mozilla session. If that fails it will try
to run a new mozilla instance, or as a last result use the Gnome help
viewer.
    
    
      
        
          
        
      
    
    
The View menu contains the System
Filters entry, used to edit the settings for the current
filters.
    
     
      
        
          
        
      
    
    
The Help menu can be used to activate online help
for eCos generally, for the synthetic target as a whole, and for
specific devices supported by the generic target. The Preferences
dialog can be used to select the browser that will be used.
    
    
      
        
          
        
      
    
    
At the time of writing there is no well-defined toplevel index file
for all eCos documentation. Hence the relevant menu item is disabled.
Documentation for the synthetic target and the supported devices
is stored as part of the package itself so can usually be found fairly
easily. It may be necessary to set the ECOS_REPOSITORY
environment variable.
    
 
  
 
  The Main Text Window
    
The central text window holds the console output from the eCos
application: the screen shot above shows DHCP initialization data from
the TCP/IP stack, and some output from the main
thread at the bottom. Some devices can insert text of their own, for
example the ethernet device support can be configured to show details
of incoming and outgoing packets. Mixing the output from the eCos
application and the various devices can make it easier to understand
the order in which events occur.
    
    
The appearance of text from different sources can be controlled by
means of filters, and it is also possible to hide some of the text.
For example, if tracing is enabled in the eCos configuration then the
trace output can be given its own colour scheme, making it stand out
from the rest of the output. In addition the trace output is generally
voluminous so it can be hidden by default, made visible only to find
out more about what was happening when a particular problem occurred.
Similarly the ethernet device support can output details of the
various packets being transferred, and using a different background
colour for this output again makes it easier to distinguish from
console output.
    
    
The default appearance for most filters is controlled via the
target definition file. An
example entry might be:
    
    
  filter trace {^TRACE:.*} -foreground HotPink1 -hide 1

    
The various colours and the hide flag for each filter can be changed
at run-time, using the System Filters item
on the View menu. This will bring up a dialog like
the following:
    
    
      
        
          
        
      
    
    
It should be noted that the text window is line-oriented, not
character-oriented. If an eCos application sends a partial line of
text then that will remain buffered until a newline character is
received, rather than being displayed immediately. This avoids
confusion when there is concurrent output from several sources.
    
    
By default the text window is read-only. This means it will not allow
cut, paste and clear operations, and keyboard input will be ignored.
The Edit menu has a checkbutton Read
Only which can be toggled to allow write operations. For
example, a user could type in a reminder of what was happening at this
time, or paste in part of a gdb session. Such keyboard input does not
get forwarded to the eCos application: if the latter requires keyboard
input then that should happen via a separate keyboard device.
    
  
 
  Positioning Optional Windows
    
Some devices may create their own subwindows, for example to monitor
ethernet traffic or to provide additional I/O facilities such as
emulated LED's or buttons. Usually the target definition file can be
used to control the layout of
these windows. This requires an understanding of the overall layout of
the display.
    
    
      
        
          
        
      
    
    
Subwindows are generally packed in one of eight frames surrounding the
central text window: .main.nw,
.main.n, .main.ne,
.main.w, .main.e,
.main.sw, .main.s, and
.main.se. To position a row of LED's above the text
window and towards the left, a target definition file could contain an
entry such as:
    
    
synth_device led {
    pack -in .main.n -side left
    …
}

    
Similarly, to put a traffic monitor window on the right of the text
window would involve something like:
    
    
    …
    monitor_pack -in .main.e -side bottom
    …

    
Often it will be sufficient to specify a container frame and one of
left, right,
top or bottom. Full control
over the positioning requires an understanding of Tcl/Tk and in
particular the packing algorithm, and an appropriate reference work
should be consulted.
    
  
 
  Global Settings
    
This section still to be written - it should document the interaction
between X resources and ecosynth, and how users can control settings
such as the main foreground and background colours.
    
  
 

 


 

  
    The Console Device
  
  
    The console device 
    Show output from the eCos application
  
 
  Description
    
The eCos application can generate text output in a variety of ways,
including calling printf or
diag_printf. When the I/O auxiliary is enabled
the eCos startup code will instantiate a console device to process all
such output. If operating in text mode the output will simply go to
standard output, or to a logfile if the -l command
line option is specified. If operating in graphical mode the output
will go to the central text window, and optionally to a logfile as
well. In addition it is possible to control the appearance of the main
text via the target definition file, and to install extra filters for
certain types of text.
    
    
It should be noted that the console device is line-oriented, not
character-oriented. This means that outputting partial lines is not
supported, and some functions such as fflush and
setvbuf will not operate as expected. This
limitation prevents much possible confusion when using filters to
control the appearance of the text window, and has some performance
benefits - especially when the eCos application generates a great deal
of output such as when tracing is enabled. For most applications this
is not a problem, but it is something that developers should be aware
of.
    
    
The console device is output-only, it does not provide any support for
keyboard input. If the application requires keyboard input then that
should be handled by a separate eCos device package and matching
host-side code.
    
  
 
  Installation
    
The eCos side of the console device is implemented by the
architectural HAL itself, in the source file
synth_diag.c, rather than in a separate device
package. Similarly the host-side implementation,
console.tcl, is part of the architectural HAL's
host-side support. It gets installed automatically alongside the I/O
auxiliary itself, so no separate installation procedure is required.
    
  
 
  Target Definition File
    
The target definition file
can contain a number of entries related to the console device. These
are all optional, they only control the appearance of text output. If
such control is desired then the relevant options should appear in the
body of a synth_device entry:
    
    
synth_device console {
    …
}

    
The first option is appearance, used to control the
appearance of any text generated by the eCos application that does not
match one of the installed filters. This option takes the same
argument as any other filter, for example:
    
    
synth_device console {
    appearance -foreground white -background black
    …
}

    
Any number of additional filters can be created with a
filter option, for example:
    
    
synth_device console {
    …
    filter trace {^TRACE:.*} -foreground HotPink1 -hide 1
    …
}

    
The first argument gives the new filter a name which will be used in
the filters dialog. Filter names
should be unique. The second argument is a Tcl regular expression. The
console support will match each line of eCos output against this
regular expression, and if a match is found then the filter will be
used for this line of text. The above example matches any line of
output that begins with TRACE:, which corresponds
to the eCos infrastructure's tracing facilities. The remaining options
control the desired appearance for matched text. If some eCos output
matches the regular expressions for several different filters then
only the first match will be used.
    
  
 
  Target-side</code></pre></td>
      </tr>
      <tr valign="middle">
         <td>1239</td>
         <td></td>
         <td></td>
         <td class="code"><pre><code>  Configuration Options
    
There are no target-side configuration options related to the console
device.
    
  
 
  Command Line Arguments
    
The console device does not use any command-line arguments.
    
  
 
  Hooks
    
The console device does not provide any hooks.
    
  
 
  Additional Tcl Procedures
    
The console device does not provide any additional Tcl procedures that
can be used by other scripts.
    
  
 

 


 

  
    System Calls
  
 
  
    cyg_hal_sys_xyz
    Access Linux system facilities
  
 
  
    
      
#include <cyg/hal/hal_io.h>
      
      
        int cyg_hal_sys_xyzzy
        
      
    
  
 
  Description
    
On a real embedded target eCos interacts with the hardware by peeking
and poking various registers, manipulating special regions of memory,
and so on. The synthetic target does not access hardware directly.
Instead I/O and other operations are emulated by making appropriate
Linux system calls. The HAL package exports a number of functions
which allow other packages, or even application code, to make these
same system calls. However this facility must be used with care: any
code which calls, for example, cyg_hal_sys_write
will only ever run on the synthetic target; that functionality is
obviously not provided on any real hardware because there is no
underlying Linux kernel to implement it.
    
    
The synthetic target only provides a subset of the available system
calls, specifically those calls which have proved useful to implement
I/O emulation. This subset can be extended fairly easily if necessary.
All of the available calls, plus associated data structures and
macros, are defined in the header file 
class="headerfile">cyg/hal/hal_io.h. There is a simple
convention: given a Linux system call such as
open, the synthetic target will prefix
cyg_hal_sys and provide a function with that name.
The second argument to the open system call is
a set of flags such as O_RDONLY, and the header
file will define a matching constant
CYG_HAL_SYS_O_RDONLY. There are also data
structures such as cyg_hal_sys_sigset_t,
matching the Linux data structure sigset_t.
    
    
In most cases the functions provided by the synthetic target behave as
per the documentation for the Linux system calls, and section 2 of the
Linux man pages can be consulted for more information. There is one
important difference: typically the documentation will say that a
function returns -1 to indicate an error, with the
actual error code held in errno; the actual
underlying system call and hence the
cyg_hal_sys_xyz provided by eCos instead returns
a negative number to indicate an error, with the absolute value of
that number corresponding to the error code; usually it is the C
library which handles this and manipulates errno, but of course
synthetic target applications are not linked with that Linux library.
    
    
However, there are some exceptions. The Linux kernel has evolved over
the years, and some of the original system call interfaces are no
longer appropriate. For example the original
select system call has been superseded by
_newselect, and that is what the
select function in the C library actually uses.
The old call is still available to preserve binary compatibility but,
like the C library, eCos makes use of the new one because it provides
the appropriate functionality. In an attempt to reduce confusion the
eCos function is called cyg_hal_sys__newselect,
in other words it matches the official system call naming scheme. The
authoritive source of information on such matters is the Linux kernel
sources themselves, and especially its header files.
    
    
eCos packages and applications should never
#include Linux header files directly. For example,
doing a #include </usr/include/fcntl.h>
to access additional macros or structure definitions, or alternatively
manipulating the header file search path, will lead to problems
because the Linux header files are likely to duplicate and clash with
definitions in the eCos headers. Instead the appropriate functionality
should be extracted from the Linux headers and moved into either
cyg/hal/hal_io.h or into
application code, with suitable renaming to avoid clashes with eCos
names. Users should be aware that large-scale copying may involve
licensing complications.
    
    
Adding more system calls is usually straightforward and involves
adding one or more lines to the platform-specific file in the
appropriate platform HAL, for example
syscall-i386-linux-1.0.S. However it is necessary
to do some research first about the exact interface implemented by the
system call, because of issues such as old system calls that have been
superseded. The required information can usually be found fairly
easily by searching through the Linux kernel sources and possibly the
GNU C library sources.
    
  

 


 

  
    Writing New Devices - target
  
  
    Writing New Devices
    extending the synthetic target, target-side
  
 
  
    
      
#include <cyg/hal/hal_io.h>
      
 
      
        int synth_auxiliary_instantiate
        const char* package
        const char* version
        const char* device
        const char* instance
        const char* data
      
      
        void synth_auxiliary_xchgmsg
        int device_id
        int request
        int arg1
        int arg2
        const unsigned char* txdata
        int txlen
        int* reply
        unsigned char* rxdata
        int* rxlen
        int max_rxlen
      
    
  
 
  Description
    
In some ways writing a device driver for the synthetic target is very
similar to writing one for a real target. Obviously it has to provide
the standard interface for that class of device, so for example an
ethernet device has to provide can_send,
send, recv and similar
functions. Many devices will involve interrupts, so the driver
contains ISR and DSR functions and will call
cyg_drv_interrupt_create,
cyg_drv_interrupt_acknowledge, and related
functions.
    
    
In other ways writing a device driver for the synthetic target is very
different. Usually the driver will not have any direct access to the
underlying hardware. In fact for some devices the I/O may not involve
real hardware, instead everything is emulated by widgets on the
graphical display. Therefore the driver cannot just peek and poke
device registers, instead it must interact with host-side code by
exchanging message. The synthetic target HAL provides a function
synth_auxiliary_xchgmsg for this purpose.
    
    
Initialization of a synthetic target device driver is also very
different. On real targets the device hardware already exists when the
driver's initialization routine runs. On the synthetic target it is
first necessary to instantiate the device inside the I/O auxiliary, by
a call to synth_auxiliary_instantiate. That
function performs a special message exchange with the I/O auxiliary,
causing it to load a Tcl script for the desired type of device and run
an instantiation procedure within that script.
    
    
Use of the I/O auxiliary is optional: if the user does not specify
--io on the command line then the auxiliary will not
be started and hence most I/O operations will not be possible. Device
drivers should allow for this possibility, for example by just
discarding any data that gets written. The HAL exports a flag
synth_auxiliary_running which should be checked.
    
  
 
  Instantiating a Device
    
Device instantiation should happen during the C++ prioritized static
constructor phase of system initialization, before control switches to
cyg_user_start and general application code. This
ensures that there is a clearly defined point at which the I/O
auxiliary knows that all required devices have been loaded. It can
then perform various consistency checks and clean-ups, run the user's
mainrc.tcl script, and make the main window
visible.
    
    
For standard devices generic eCos I/O code will call the device
initialization routines at the right time, iterating through the
DEVTAB table in a static constructor. The same
holds for network devices and file systems. For more custom devices
code like the following can be used:
    
    
#include <cyg/infra/cyg_type.h>
class mydev_init {
  public:
    mydev_init() {
        …
    }
};
static mydev_init mydev_init_object CYGBLD_ATTRIB_INIT_PRI(CYG_INIT_IO);

    
Some care has to be taken because the object
mydev_init_object will typically not be referenced
by other code, and hence may get eliminated at link-time. If the code
is part of an eCos package then problems can be avoided by putting the
relevant file in libextras.a:
    
    
cdl_package CYGPKG_DEVS_MINE {
    …
    compile -library=libextras.a init.cxx
}

    
For devices inside application code the same can be achieved by
linking the relevant module as a .o file rather
than putting it in a .a library.
    
    
In the device initialization routine the main operation is a call to
synth_auxiliary_instantiate. This takes five
arguments, all of which should be strings:
    
    
      
        package
        
For device drivers which are eCos packages this should be a directory
path relative to the eCos repository, for example
devs/eth/synth/ecosynth. This will allow the I/O
auxiliary to find the various host-side support files for this package
within the install tree. If the device is application-specific and not
part of an eCos package then a NULL pointer can be used, causing the
I/O auxiliary to search for the support files in the current directory
and then in ~/.ecos/synth
instead.
        
      
      
        version
        
For eCos packages this argument should be the version of the package
that is being used, for example current. A simple
way to get this version is to use the
SYNTH_MAKESTRING macro on the package name.
If the device is application-specific then a NULL pointer should be
used.
        
      
      
        device
        
This argument specifies the type of device being instantiated, for
example ethernet. More specifically the I/O
auxiliary will append a .tcl suffix, giving
the name of a Tcl script that will handle all I/O requests for the
device. If the application requires several instances of a type
of device then the script will only be loaded once, but the script
will contain an instantiation procedure that will be called for each
device instance.
        
      
      
        instance
        
If it is possible to have multiple instances of a device then this
argument identifies the particular instance, for example
eth0 or eth1. Otherwise a NULL
pointer can be used.
        
      
      
        data
        
This argument can be used to pass additional initialization data from
eCos to the host-side support. This is useful for devices where eCos
configury must control certain aspects of the device, rather than
host-side configury such as the target definition file, because eCos
has compile-time dependencies on some or all of the relevant options.
An example might be an emulated frame buffer where eCos has been
statically configured for a particular screen size, orientation and
depth. There is no fixed format for this string, it will be
interpreted only by the device-specific host-side Tcl script. However
the string length should be limited to a couple of hundred bytes to
avoid possible buffer overflow problems.
        
      
    
    
Typical usage would look like:
    
    
    if (!synth_auxiliary_running) {
      return;
    }
    id = synth_auxiliary_instantiate("devs/eth/synth/ecosynth",
             SYNTH_MAKESTRING(CYGPKG_DEVS_ETH_ECOSYNTH),
             "ethernet",
             "eth0",
             (const char*) 0);

    
The return value will be a device identifier which can be used for
subsequent calls to synth_auxiliary_xchgmsg. If
the device could not be instantiated then -1 will
be returned. It is the responsibility of the host-side software to
issue suitable diagnostics explaining what went wrong, so normally the
target-side code should fail silently.
    
    
Once the desired device has been instantiated, often it will be
necessary to do some additional initialization by a message exchange.
For example an ethernet device might need information from the
host-side about the MAC address, the 
linkend="synth-new-target-interrupts">interrupt vector, and
whether or not multicasting is supported.
    
  
 
  Communicating with a Device
    
Once a device has been instantiated it is possible to perform I/O by
sending messages to the appropriate Tcl script running inside the
auxiliary, and optionally getting back replies. I/O operations are
always initiated by the eCos target-side, it is not possible for the
host-side software to initiate data transfers. However the host-side
can raise interrupts, and the interrupt handler inside the target can
then exchange one or more messages with the host.
    
    
There is a single function to perform I/O operations,
synth_auxiliary_xchgmsg. This takes the following
arguments:
    
    
      
        device_id
         
This should be one of the identifiers returned by a previous
call to synth_auxiliary_instantiate, specifying the
particular device which should perform some I/O.
         
       
      
        request
         
Request are just signed 32-bit integers that identify the particular
I/O operation being requested. There is no fixed set of codes, instead
each type of device can define its own.
         
       
      
        arg1
        arg2
         
For some requests it is convenient to pass one or two additional
parameters alongside the request code. For example an ethernet device
could define a multicast-all request, with arg1
controlling whether this mode should be enabled or disabled. Both
arg1 and arg2 should be signed
32-bit integers, and their values are interpreted only by the
device-specific Tcl script.
         
       
      
        txdata
        txlen
         
Some I/O operations may involve sending additional data, for example
an ethernet packet. Alternatively a control operation may require many
more parameters than can easily be encoded in arg1
and arg2, so those parameters have to be placed in
a suitable buffer and extracted at the other end.
txdata is an arbitrary buffer of
txlen bytes that should be sent to the host-side.
There is no specific upper bound on the number of bytes that can be
sent, but usually it is a good idea to allocate the transmit buffer
statically and keep transfers down to at most several kilobytes.
         
       
      
        reply
         
If the host-side is expected to send a reply message then
reply should be a pointer to an integer variable
and will be updated with a reply code, a simple 32-bit integer. The
synthetic target HAL code assumes that the host-side and target-side
agree on the protocol being used: if the host-side will not send a
reply to this message then the reply argument
should be a NULL pointer; otherwise the host-side must always send
a reply code and the reply argument must be valid.
         
       
      
        rxdata
        rxlen
         
Some operations may involve additional data coming from the host-side,
for example an incoming ethernet packet. rxdata
should be a suitably-sized buffer, and rxlen a
pointer to an integer variable that will end up containing the number
of bytes that were actually received. These arguments will only be
used if the host-side is expected to send a reply and hence the
reply argument was not NULL.
         
       
      
        max_rxlen
         
If a reply to this message is expected and that reply may involve
additional data, max_rxlen limits the size of that
reply. In other words, it corresponds to the size of the
rxdata buffer.
         
       
    
    
Most I/O operations involve only some of the arguments. For example
transmitting an ethernet packet would use the
request, txdata and
txlen fields (in addition to
device_id which is always required), but would not
involve arg1 or arg2 and no
reply would be expected. Receiving an ethernet packet would involve
request, rxdata,
rxlen and max_rxlen; in addition
reply is needed to get any reply from the host-side
at all, and could be used to indicate whether or not any more packets
are buffered up. A control operation such as enabling multicast mode
would involve request and arg1,
but none of the remaining arguments.
    
  
 
  Interrupt Handling
    
Interrupt handling in the synthetic target is much the same as on a
real target. An interrupt object is created using
cyg_drv_interrupt_create, attached, and unmasked.
The emulated device - in other words the Tcl script running inside the
I/O auxiliary - can raise an interrupt. Subject to interrupts being
disabled and the appropriate vector being masked, the system will
invoke the specified ISR function. The synthetic target HAL
implementation does have some limitations: there is no support for
nested interrupts, interrupt priorities, or a separate interrupt
stack. Supporting those might be appropriate when targetting a
simulator that attempts to model real hardware accurately, but not for
the simple emulation provided by the synthetic target.
    
    
Of course the actual implementation of the ISR and DSR functions will
be rather different for a synthetic target device driver. For real
hardware the device driver will interact with the device by reading
and writing device registers, managing DMA engines, and the like. A
synthetic target driver will instead call
synth_auxiliary_xchgmsg to perform the I/O
operations.
    
    
There is one other significant difference between interrupt handling
on the synthetic target and on real hardware. Usually the eCos code
will know which interrupt vectors are used for which devices. That
information is fixed when the target hardware is designed. With the
synthetic target interrupt vectors are assigned to devices on the host
side, either via the target definition file or dynamically when the
device is instantiated. Therefore the initialization code for a
target-side device driver will need to request interrupt vector
information from the host-side, via a message exchange. Such interrupt
vectors will be in the range 1 to 31 inclusive, with interrupt 0 being
reserved for the real-time clock.
    
  
 

 


 

  
    Writing New Devices - host
  
  
    Writing New Devices
    extending the synthetic target, host-side
  
 
  Description
    
On the host-side adding a new device means writing a Tcl/Tk script
that will handle instantiation and subsequent requests from the
target-side. These scripts all run in the same full interpreter,
extended with various commands provided by the main I/O auxiliary
code, and running in an overall GUI framework. Some knowledge of
programming with Tcl/Tk is required to implement host-side device
support.
    
    
Some devices can be implemented entirely using a Tcl/Tk script. For
example, if the final system will have some buttons then those can be
emulated in the synthetic target using a few Tk widgets. A simple
emulation could just have the right number of buttons in a row. A more
advanced emulation could organize the buttons with the right layout,
perhaps even matching the colour scheme, the shapes, and the relative
sizes. With other devices it may be necessary for the Tcl script to
interact with an external program, because the required functionality
cannot easily be accessed from a Tcl script. For example interacting
with a raw ethernet device involves some ioctl
calls, which is easier to do in a C program. Therefore the
ethernet.tcl script which implements the
host-side ethernet support spawns a separate program
rawether, written in C, that performs the
low-level I/O. Raw ethernet access usually also requires root
privileges, and running a small program rawether
with such privileges is somewhat less of a security risk than the
whole eCos application, the I/O auxiliary, and various dynamically
loaded Tcl scripts.
    
    
Because all scripts run in a single interpreter, some care has
to be taken to avoid accidental sharing of global variables. The best
way to avoid problems is to have each script create its own Tcl
namespace, so for example the ethernet.tcl script
creates a namespace ethernet:: and all variables
and procedures reside in this namespace. Similarly the I/O auxiliary
itself makes use of a synth:: namespace.
    
  
 
  Building and Installation
    
When an eCos device driver or application code instantiates a device,
the I/O auxiliary will attempt to load a matching Tcl script. The
third argument to synth_auxiliary_instantiate
specifies the type of device, for example ethernet,
and the I/O auxiliary will append a .tcl suffix
and look for a script ethernet.tcl.
    
    
If the device being instantiated is application-specific rather than
part of an eCos package, the I/O auxiliary will look first in the
current directory, then in 
class="directory">~/.ecos/synth. If it is part of an eCos
package then the auxiliary will expect to find the Tcl script and any
support files below 
class="directory">libexec/ecos in the install tree - note
that the same install tree must be used for the I/O auxiliary itself
and for any device driver support. The directory hierarchy below
libexec/ecos matches the
structure of the eCos repository, allowing multiple versions of a
package to be installed to allow for incompatible protocol changes.
    
    
The preferred way to build host-side software is to use
autoconf and automake. Usually
this involves little more than copying the
acinclude.m4, configure.in
and Makefile.am files from an existing package,
for example the synthetic target ethernet driver, and then making
minor edits. In acinclude.m4 it may be necessary
to adjust the path to the root of the repository.
configure.in may require a similar change, and
the AC_INIT macro invocation will have to be
changed to match one of the files in the new package. A critical macro
in this file is ECOS_PACKAGE_DIRS which will set
up the correct install directory. Makefile.am may
require some more changes, for example to specify the data files that
should be installed (including the Tcl script). These files should
then be processed using aclocal,
autoconf and automake in that
order. Actually building the software then just involves
configure, make and
make install, as per the instructions in the
toplevel README.host file.
    
    
To assist developers, if the environment variable
ECOSYNTH_DEVEL is set then a slightly different
algorithm is used for locating device Tcl scripts. Instead of looking
only in the install tree the I/O auxiliary will also look in the
source tree, and if the script there is more recent than the installed
version it will be used in preference. This allows developers to
modify the master copy without having to run make
install all the time.
    
    
If a script needs to know where it has been installed it can examine
the Tcl variable synth::device_install_dir . This
variable gets updated whenever a  script is loaded, so if the
value may be needed later it should be saved away in a device-specific
variable.
    
  
 
  Instantiation
    
The I/O auxiliary will source the device-specific
Tcl script when the eCos application first attempts to instantiate a
device of that type. The script should return a procedure that will be
invoked to instantiate a device.
    
    
namespace eval ethernet {
    …
    proc instantiate { id instance data } {
        …
        return ethernet::handle_request
    }
}
return ethernet::instantiate

    
The id argument is a unique identifier for this
device instance. It will also be supplied on subsequent calls to the
request handler, and will match the return value of
synth_auxiliary_instantiate on the target side. A
common use for this value is as an array index to support multiple
instances of this types of device. The instance and
data arguments match the corresponding arguments to
synth_auxiliary_instantiate on the target side, so
a typical value for instance would be
eth0, and data is used to pass
arbitrary initialization parameters from target to host.
    
    
The actual work done by the instantiation procedure is obviously
device-specific. It may involve allocating an 
linkend="synth-new-host-interrupts">interrupt vector, adding a
device-specific subwindow to the display, opening a real Linux device,
establishing a socket connection to some server, spawning a separate
process to handle the actual I/O, or a combination of some or all of
the above.
    
    
If the device is successfully instantiated then the return value
should be a handler for subsequent I/O requests. Otherwise the return
value should be an empty string, and on the target-side the
synth_auxiliary_instantiate call will return
-1. The script is responsible for providing
diagnostics explaining
why the device could not be instantiated.
    
  
 
  Handling Requests
    
When the target-side calls
synth_auxiliary_xchgmsg, the I/O auxiliary will
end up calling the request handler for the appropriate device instance
returned during instantiation:
    
    
namespace eval ethernet {
    …
    proc handle_request { id request arg1 arg2 txdata txlen max_rxlen } {
        …
        if { <some condition> } {
            synth::send_reply <error code> 0 ""
            return
        }
        …
        synth::send_reply <reply code> $packet_len $packet
    }
    …
}

    
The id argument is the same device id that was
passed to the instantiate function, and is typically used as an array
index to access per-device data. The request,
arg1, arg2, and
max_rxlen are the same values that were passed to
synth_auxiliary_xchgmsg on the target-side,
although since this is a Tcl script obviously the numbers have been
converted to strings. The txdata buffer is raw data
as transmitted by the target, or an empty string if the I/O operation
does not involve any additional data. The Tcl procedures
binary scan, string index and
string range may be found especially useful when
manipulating this buffer. txlen is provided for
convenience, although string length $txdata would
give the same information.
    
    
The code for actually processing the request is of course device
specific. If the target does not expect a reply then the request
handler should just return when finished. If a reply is expected then
there should be a call to synth::send_reply. The
first argument is the reply code, and will be turned into a 32-bit
integer on the target side. The second argument specifies the length
of the reply data, and the third argument is the reply data itself.
For some devices the Tcl procedure binary format
may prove useful. If the reply involves just a code and no additional
data, the second and third arguments should be 0
and an empty string respectively.
    
    
Attempts to send a reply when none is expected, fail to send a reply
when one is expected, or send a reply that is larger than the
target-side expects, will all be detected by the I/O auxiliary and
result in run-time error messages.
    
    
It is not possible for the host-side code to send unsolicited messages
to the target. If host-side code needs attention from the target, for
example because some I/O operation has completed, then an interrupt
should be raised.
    
  
 
  Interrupts
    
The I/O auxiliary provides a number of procedures for interrupt
handling.
    
    
synth::interrupt_allocate <name>
synth::interrupt_get_max
synth::interrupt_get_devicename <vector>
synth::interrupt_raise <vector>

    
synth::interrupt_allocate is normally called during
device instantiation, and returns the next free interrupt vector. This
can be passed on to the target-side device driver in response to a
suitable request, and it can then install an interrupt handler on that
vector. Interrupt vector 0 is used within the
target-side code for the real-time clock, so the allocated vectors
will start at 1. The argument identifies the
device, for example eth0. This is not actually used
internally, but can be accessed by user-initialization scripts that
provide some sort of interrupt monitoring facility (typically via the
interrupt 
linkend="synth-new-host-hooks">hook). It is possible for a
single device to allocate multiple interrupt vectors, but the
synthetic target supports a maximum of 32 such vectors.
    
    
synth::interrupt_get_max returns the highest
interrupt vector that has been allocated, or 0 if
there have been no calls to
synth::interrupt_allocate.
synth::interrupt_get_devicename returns the string
that was passed to synth::interrupt_allocate when
the vector was allocated.
    
    
synth::interrupt_raise can be called any time after
initialization. The argument should be the vector returned by
synth::interrupt_allocate for this device. It will
activate the normal eCos interrupt handling mechanism so, subject to
interrupts being enabled and this particular interrupt not being
masked out, the appropriate ISR will run.
    
    
At this time it is not possible for a device to allocate a specific
interrupt vector. The order in which interrupt vectors are assigned to
devices effectively depends on the order in which the eCos devices get
initialized, and that may change if the eCos application is rebuilt. A
future extension may allow devices to allocate specific vectors, thus
making things more deterministic. However that will introduce new
problems, in particular the code will have to start worrying about
requests for vectors that have already been allocated.
    
  
 
  Flags and Command Line Arguments
    
The generic I/O auxiliary code will process the standard command line
arguments, and will set various flag variables accordingly. Some of
these should be checked by device-specific scripts.
    
    
      
        synth::flag_gui
        
This is set when the I/O auxiliary is operating in graphical mode
rather than text mode. Some functionality such as filters and the GUI
layout are only available in graphical mode.
        
        
    if { $synth::flag_gui } {
        …
    }

      
      
        synth::flag_verbose
         
The user has requested additional information during startup. Each
device driver can decide how much additional information, if any,
should be produced.
         
      
      
        synth::flag_keep_going
        
The user has specified -k or
--keep-going, so even if an error occurs the I/O
auxiliary and the various device driver scripts should continue running
if at all possible. Diagnostics should still be generated.
        
      
    
    
Some scripts may want to support additional command line arguments.
This facility should be used with care since there is no way to
prevent two different scripts from trying to use the same argument.
The following Tcl procedures are available:
    
    
synth::argv_defined <name>
synth::argv_get_value <name>

    
synth::argv_defined returns a boolean to indicate
whether or not a particular argument is present. If the argument is
the name part of a name/value pair, an = character
should be appended. Typical uses might be:
    
    
    if { [synth::argv_defined "-o13"] } {
        …
    }
 
    if { [synth::argv_defined "-mark="] } {
        …
    }

    
The first call checks for a flag -o13 or
--o13 - the code treats options with single and
double hyphens interchangeably. The second call checks for an argument
of the form -mark=<value> or a pair of
arguments -mark <value>. The value part of a
name/value pair can be obtained using
synth::argv_get_value;
    
    
    variable speed 1
    if { [synth::argv_defined "-mark="] } {
        set mark [synth::argv_get_value "-mark="]
        if { ![string is integer $mark] || ($mark < 1) || ($mark > 9) } {
            <issue diagnostic>
        } else {
            set speed $mark
        }
    }

    
synth::argv_get_value should only be used after a
successful call to synth::argv_defined.
At present there is no support for some advanced forms of command line
argument processing. For example it is not possible to repeat a
certain option such as -v or
--verbose, with each occurrence increasing the level
of verbosity.
    
    
If a script is going to have its own set of command-line arguments
then it should give appropriate details if the user specifies
--help. This involves a hook function:
    
    
namespace eval my_device {
    proc help_hook { } {
        puts " -o13          : activate the omega 13 device"
        puts " -mark <speed> : set speed. Valid values are 1 to 9."
    }
 
    synth::hook_add "help" my_device::help_hook
}

  
 
  The Target Definition File
    
Most device scripts will want to check entries in the target
definition file for run-time configuration information. The Tcl
procedures for this are as follows:
    
    
synth::tdf_has_device <name>
synth::tdf_get_devices
synth::tdf_has_option <devname> <option>
synth::tdf_get_option <devname> <option>
synth::tdf_get_options <devname> <option>
synth::tdf_get_all_options <devname>

    
synth::tdf_has_device can be used to check whether
or not the target definition file had an entry
synth_device <name>. Usually the name
will match the type of device, so the
console.tcl script will look for a target
definition file entry console.
synth::tdf_get_devices returns a list of all
device entries in the target definition file.
    
    
Once it is known that the target definition file has an entry for a
certain device, it is possible to check for options within the entry.
synth::tdf_has_option just checks for the presence,
returning a boolean:
    
    
    if { [synth::tdf_has_option "console" "appearance"] } {
        …
    }

    
synth::tdf_get_option returns a list of all the
arguments for a given option. For example, if the target definition
file contains an entry:
    
    
synth_device console {
    appearance -foreground white -background black
    filter trace {^TRACE:.*} -foreground HotPink1 -hide 1
    filter xyzzy {.*xyzzy.*} -foreground PapayaWhip
}

    
A call
synth::tdf_get_option console appearance
will return the list {-foreground white -background
black}. This list can be manipulated using standard Tcl routines
such as llength and lindex. Some
options can occur multiple times in one entry, for example
filter in the console entry.
synth::tdf_get_options returns a list of lists,
with one entry for each option occurrence.
synth::tdf_get_all_options returns a list of lists
of all options. This time each entry will include the option name as
well.
    
    
The I/O auxiliary will not issue warnings about entries in the target
definition file for devices which were not loaded, unless the
-v or --verbose command line
argument was used. This makes it easier to use a single target
definition file for different applications. However the auxiliary will
issue warnings about options within an entry that were ignored,
because often these indicate a typing mistake of some sort. Hence a
script should always call synth::tdf_has_option,
synth:;tdf_get_option or
synth::tdf_get_options for all valid options, even
if some of the options preclude the use of others.
    
  
 
  Hooks
    
Some scripts may want to take action when particular events occur, for
example when the eCos application has exited and there is no need for
further I/O. This is supported using hooks:
    
    
namespace eval my_device {
    …
    proc handle_ecos_exit { arg_list } {
        …
    }
    synth::hook_add "ecos_exit" my_device::handle_ecos_exit
}

    
It is possible for device scripts to add their own hooks and call all
functions registered for those hooks. A typical use for this is by
user initialization scripts that want to monitor some types of I/O.
The available Tcl procedures for manipulating hooks are:
    
    
synth::hook_define <name>
synth::hook_defined <name>
synth::hook_add <name> <function>
synth::hook_call <name> <args>

    
synth::hook_define creates a new hook with the
specified name. This hook must not already exist.
synth::hook_defined can be used to check for the
existence of a hook. synth::hook_add allows other
scripts to register a callback function for this hook, and
synth::hook_call allows the owner script to invoke
all such callback functions. A hook must already be defined before a
callback can be attached. Therefore typically device scripts will only
use standard hooks and their own hooks, not hooks created by some
other device, because the order of device initialization is not
sufficiently defined. User scripts run from
mainrc.tcl can use any hooks that have been
defined.
    
    
synth::hook_call takes an arbitrary list of
arguments, for example:
    
    
    synth::hook_call "ethernet_rx" "eth0" $packet

    
The callback function will always be invoked with a single argument,
a list of the arguments that were passed to
synth::hook_call:
    
    
    proc rx_callback { arg_list } {
        set device [lindex $arg_list 0]
        set packet [lindex $arg_list 1]
    }

    
Although it might seem more appropriate to use Tcl's
eval procedure and have the callback functions
invoked with the right number of arguments rather than a single list,
that would cause serious problems if any of the data contained special
characters such as [ or $. The
current implementation of hooks avoids such problems, at the cost of
minor inconvenience when writing callbacks.
    
    
A number of hooks are defined as standard. Some devices will add
additional hooks, and the device-specific documentation should be
consulted for those. User scripts can add their own hooks if desired.
    
    
      
        exit
        
This hook is called just before the I/O auxiliary exits. Hence it
provides much the same functionality as atexit in
C programs. The argument list passed to the callback function will be
empty.
        
      
      
        ecos_exit
        
This hook is called when the eCos application has exited. It is used
mainly to shut down I/O operations: if the application is no longer
running then there is no point in raising interrupts or storing
incoming packets. The callback argument list will be empty.
        
      
      
        ecos_initialized
        
The synthetic target HAL will send a request to the I/O auxiliary once
the static constructors have been run. All devices should now have been
instantiated. A script could now check how many instances there are of
a given type of device, for example ethernet devices, and create a
little monitor window showing traffic on all the devices. The
ecos_initialized callbacks will be run just before
the user's mainrc.tcl script. The callback
argument list will be empty.
        
      
      
        help
        
This hook is also invoked once static constructors have been run, but
only if the user specified -h or
--help. Any scripts that add their own command line
arguments should add a callback to this hook which outputs details of
the additional arguments. The callback argument list will be empty.
        
      
      
        interrupt
        
Whenever a device calls synth::interrupt_raise the
interrupt hook will be called with a single
argument, the interrupt vector. The main use for this is to allow
user scripts to monitor interrupt traffic.
        
      
    
  
 
  Output and Filters
    
Scripts can use conventional facilities for sending text output to the
user, for example calling puts or directly
manipulating the central text widget
.main.centre.text. However in nearly all cases it
is better to use output facilities provided by the I/O auxiliary
itself:
    
    
synth::report <msg>
synth::report_warning <msg>
synth::report_error <msg>
synth::internal_error <msg>
synth::output <msg> <filter>

    
synth::report is intended for messages related to
the operation of the I/O auxiliary itself, especially additional
output resulting from -v or
--verbose. If running in text mode the output will go
to standard output. If running in graphical mode the output will go to
the central text window. In both modes, use of -l or
--logfile will modify the behaviour.
    
    
synth::report_warning,
synth::report_error and
synth::internal_error have the obvious meaning,
including prepending strings such as Warning: and
Error:. When the eCos application informs the I/O
auxiliary that all static constructors have run, if at that point
there have been any calls to synth::error then the
I/O auxiliary will exit. This can be suppressed with command line
arguments -k or --keep-going.
synth::internal_error will output some information
about the current state of the I/O auxiliary and then exit
immediately. Of course it should never be necessary to call this
function.
    
    
synth::output is the main routine for outputting
text. The second argument identifies a filter. If running in text mode
the filter is ignored, but if running in graphical mode the filter can
be used to control the appearance of this output. A typical use would
be:
    
    
    synth::output $line "console"

    
This outputs a single line of text using the
console filter. If running in graphical mode the
default appearance of this text can be modified with the
appearance option in the
synth_device console entry of the target
definition file. The System filters menu
option can be used to change the appearance at run-time.
    
    
Filters should be created before they are used. The procedures
available for this are:
    
    
synth::filter_exists <name>
synth::filter_get_list
synth::filter_add <name> [options]
synth::filter_parse_options <options> <parsed_options> <message>
synth::filter_add_parsed <name> <parsed_options>

    
synth::filter_exists can be used to check whether
or not a particular filter already exists: creating two filters with
the same name is not allowed.
synth::filter_get_list returns a list of the
current known filters. synth::filter_add can be
used to create a new filter. The first argument names the new filter,
and the remaining arguments control the initial appearance. A typical
use might be:
    
    
    synth::filter_add "my_device_tx" -foreground yellow -hide 1

    
It is assumed that the supplied arguments are valid, which typically
means that they are hard-wired in the script. If instead the data
comes out of a configuration file and hence may be invalid, the
I/O auxiliary provides a parsing utility. Typical usage would be:
    
    
    array set parsed_options [list]
    set message ""
    if { ![synth::filter_parse_options $console_appearance parsed_options message] } {
        synth::report_error \
                "Invalid entry in target definition file $synth::target_definition\
                 \n  synth_device \"console\", entry \"appearance\"\n$message"
    } else {
        synth::filter_add_parsed "console" parsed_options
    }

    
On success parsed_options will be updated with an
internal representation of the desired appearance, which can then be
used in a call to synth::filter_add_parsed. On
failure message will be updated with details of the
parsing error that occurred.
    
  
 
  The Graphical Interface
    
When the I/O auxiliary is running in graphical mode, many scripts will
want to update the user interface in some way. This may be as simple
as adding another entry to the help menu for the device, or adding a
new button to the toolbar. It may also involve adding new subwindows,
or even creating entire new toplevel windows. These may be simple
monitor windows, displaying additional information about what is going
on in the system in a graphical format. Alternatively they may emulate
actual I/O operations, for example button widgets could be used to
emulate real physical buttons.
    
    
The I/O auxiliary does not provide many procedures related to the
graphical interface. Instead it is expected that scripts will just
update the widget hierarchy directly.
    
    
      
        
          
        
      
    
    
So adding a new item to the Help menu involves a
.menubar.help add operation with suitable
arguments. Adding a new button to the toolbar involves creating a
child window in .toolbar and packing it
appropriately. Scripts can create their own subwindows and then pack
it into one of .main.nw,
.main.n, .main.ne,
.main.w, .main.e,
.main.sw, .main.s or
.main.se. Normally the user should be allowed to
control this via the target
definition file. The central window .main.centre
should normally be left alone by other scripts since it gets used for
text output.
    
    
The following graphics-related utilities may be found useful:
    
    
synth::load_image <image name> <filename>
synth::register_ballon_help <widget> <message>
synth::handle_help <URL>

    
synth::load_image can be used to add a new image to
the current interpreter. If the specified file has a
.xbm extension then the image will be a
monochrome bitmap, otherwise it will be a colour image of some sort.
A boolean will be returned to indicate success or failure, and
suitable diagnostics will be generated if necessary.
    
    
synth::register_balloon_help provides balloon help
for a specific widget, usually a button on the toolbar.
    
    
synth::handle_help is a utility routine that can be
installed as the command for displaying online help, for example:
    
    
    .menubar.help add command -label "my device" -command \
        [list synth::handle_help "file://$path"]

  
 

 


 

  
    Porting
  
  
    Porting
    Adding support for other hosts
  
 
  Description
    
The initial development effort of the eCos synthetic target happened
on x86 Linux machines. Porting to other platforms involves addressing
a number of different issues. Some ports should be fairly
straightforward, for example a port to Linux on a processor other than
an x86. Porting to Unix or Unix-like operating systems other than
Linux may be possible, but would involve more effort. Porting to a
completely different operating system such as Windows would be very
difficult. The text below complements the eCos Porting Guide.
    
  
 
  Other Linux Platforms
    
Porting the synthetic target to a Linux platform that uses a processor
other than x86 should be straightforward. The simplest approach is to
copy the existing i386linux
directory tree in the hal/synth
hierarchy, then rename and edit the ten or so files in this package.
Most of the changes should be pretty obvious, for example on a 64-bit
processor some new data types will be needed in the
basetype.h header file. It will also be necessary
to update the toplevel ecos.db database with an
entry for the new HAL package, and a new target entry will be needed.
    
    
Obviously a different processor will have different register sets and
calling conventions, so the code for saving and restoring thread
contexts and for implementing setjmp and
longjmp will need to be updated. The exact way of
performing Linux system calls will vary: on x86 linux this usually
involves pushing some registers on the stack and then executing an
int 0x080 trap instruction, but on a different
processor the arguments might be passed in registers instead and
certainly a different trap instruction will be used. The startup code
is written in assembler, but needs to do little more than extract the
process' argument and environment variables and then jump to the main
linux_entry function provided by the
architectural synthetic target HAL package.
    
    
The header file hal_io.h provided by the
architectural HAL package provides various structure definitions,
function prototypes, and macros related to system calls. These are
correct for x86 linux, but there may be problems on other processors.
For example a structure field that is currently defined as a 32-bit
number may in fact may be a 64-bit number instead.
    
    
The synthetic target's memory map is defined in two files in the
include/pkgconf subdirectory.
For x86 the default memory map involves eight megabytes of read-only
memory for the code at location 0x1000000 and another eight megabytes
for data at 0x2000000. These address ranges may be reserved for other
purposes on the new architecture, so may need changing. There may be
some additional areas of memory allocated by the system for other
purposes, for example the startup stack and any environment variables,
but usually eCos applications can and should ignore those.
    
    
Other HAL functionality such as interrupt handling, diagnostics, and
the system clock are provided by the architectural HAL package and
should work on different processors with few if any changes. There may
be some problems in the code that interacts with the I/O auxiliary
because of lurking assumptions about endianness or the sizes of
various data types.
    
    
When porting to other processors, a number of sources of information
are likely to prove useful. Obviously the Linux kernel sources and
header files constitute the ultimate authority on how things work at
the system call level. The GNU C library sources may also prove very
useful: for a normal Linux application it is the C library that
provides the startup code and the system call interface.
    
  
 
  Other Unix Platforms
    
Porting to a Unix or Unix-like operating system other than Linux would
be somewhat more involved. The first requirement is toolchains: the
GNU compilers, gcc and g++, must definitely be used; use of other GNU
tools such as the linker may be needed as well, because eCos depends
on functionality such as prioritizing C++ static constructors, and
other linkers may not implement this or may implement it in a
different and incompatible way. A closely related requirement is the
use of ELF format for binary executables: if the operating system
still uses an older format such as COFF then there are likely to be
problems because they do not provide the flexibility required by eCos.
    
    
In the architectural HAL there should be very little code that is
specific to Linux. Instead the code should work on any operating
system that provides a reasonable implementation of the POSIX
standard. There may be some problems with program startup, but those
could be handled at the architectural level. Some changes may also be
required to the exception handling code. However one file which will
present a problem is hal_io.h, which contains
various structure definitions and macros used with the system call
interface. It is likely that many of these definitions will need
changing, and it may well be appropriate to implement variant HAL
packages for the different operating systems where this information
can be separated out. Another possible problem is that the generic
code assumes that system calls such as
cyg_hal_sys_write are available. On an operating
system other than Linux it is possible that some of these are not
simple system calls, and instead wrapper functions will need to be
implemented at the variant HAL level.
    
    
The generic I/O auxiliary code should be fairly portable to other Unix
platforms. However some of the device drivers may contain code that is
specific to Linux, for example the PF_PACKET socket
address family and the ethertap virtual tunnelling interface. These
may prove quite difficult to port.
    
    
The remaining porting task is to implement one or more platform HAL
packages, one per processor type that is supported. This should
involve much the same work as a port to 
linkend="synth-porting-linux">another processor running Linux.
    
    
When using other Unix operating systems the kernel source code may not
be available, which would make any porting effort more challenging.
However there is still a good chance that the GNU C library will have
been ported already, so its source code may contain much useful
information.
    
  
 
  Windows Platforms
    
Porting the current synthetic target code to some version of Windows
or to another non-Unix platform is likely to prove very difficult. The
first hurdle that needs to be crossed is the file format for binary
executables: current Windows implementations do not use ELF, instead
they use their own format PE which is a variant of the rather old and
limited COFF format. It may well prove easier to first write an ELF
loader for Windows executables, rather than try to get eCos to work
within the constraints of PE. Of course that introduces new problems,
for example existing source-level debuggers will still expect
executables to be in PE format.
    
    
Under Linux a synthetic target application is not linked with the
system's C library or any other standard system library. That would
cause confusion, for example both eCos and the system's C library
might try to define the printf function, and
introduce complications such as working with shared libraries. For
much the same reasons, a synthetic target application under Windows
should not be linked with any Windows DLL's. If an ELF loader has been
specially written then this may not be much of a problem.
    
    
The next big problem is the system call interface. Under Windows
system calls are generally made via DLL's, and it is not clear that
the underlying trap mechanism is well-documented or consistent between
different releases of Windows.
    
    
The current code depends on the operating system providing an
implementation of POSIX signal handling. This is used for I/O
purposes, for example SIGALRM is used for the
system clock, and for exceptions. It is not known what equivalent
functionality is available under Windows.
    
    
Given the above problems a port of the synthetic target to Windows may
or may not be technically feasible, but it would certainly require a
very large amount of effort.
    
  
 

 

 

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [packages/] [hal/] [synth/] [arch/] [current/] [doc/] [synth.sgml] - Blame information for rev 838
