New data types and library functions are added to the DPT4 API for accessing signaling channels. A new test and example program is included in bin/dpsignaling.c. Below is a synopsis of the new library functions. The DPT4 Programmer's Manual will be updated in the near future to describe the details of signaling channels.

   PCI_SIGNAL *
   dp_open_signal (
        int      pci_id,
        char     framer_id,
        int      flags, 
        uint32_t signalMask )

This function is used in much the same way as the pci_open_chan function. It returns a special signaling handle that is used by other functions for reading and writing signaling data from the channel.

The pci_id argument specifies the DPT board number (e.g. 0 for dpt0). The framer_id argument specifies one of four framers on the board, the flags argument uses the same macros as the pci_open_chan function to specify certain channel options. The flags supported by dp_open_signal are CHAN_READ, CHAN_WRITE and CHAN_NOMAP. The signalMask argument is a bit-mask specifying which time slots to read signaling data for.

The return value is a pointer to the signaling handle or NULL if an error is detected. The successful handle returned must be saved to be passed to the other signaling functions.

Before signaling channels can be opened, the framer must be configured. This is done by the pci_open_chan function or the pci_framer_set_mode function may be used if no data channels are open before signaling channels.

   int
   dp_close_signal ( PCI_SIGNAL *signal )

This function closes the signaling channel. It frees device resources and memory that was allocated for the signaling handle. The return value is 1 on success or 0 fan error is detected.

   int
   dp_read_signal (
        PCI_SIGNAL      *signal,
        dpt_signalbuf_t *sigBuf )

This function reads (receives) signaling data from the signaling channel. The first time this function is called after opening a signaling channel it will return immediately with the current signaling data for the requested time slots. Subsequent calls to dp_read_signal will block until the signaling state changes for any of the requested time slots.

The data is stored in the special signaling buffer data type, dpt_signalbuf_t or signalBuf_t. Application programs must declare and allocate the signal buffer and pass its address to the dp_read_signal function.

The dp_read_signal function returns the number of data bytes read from the channel (up to 32 bytes at a time) or -1 in the case of an error.

For successful signaling reads the data is available in the data member of the signal buffer. For example:

    PCI_SIGNAL       *signal
    dpt_signal_buf_t  sigbuf;

    signal = dp_open_signal(0, 1, CHAN_READ, 0xf) ;
    if (signal == NULL)
        error();
    if (dp_read_signal(signal) < 0)
        error();
    printf("Signal data: %x %x %x %x\n",
        sigbuf.data[0], sigbuf.data[1], sigbuf.data[2], sigbuf.data[3]);

   int
   dp_get_signal (
        PCI_SIGNAL      *signal,
        dpt_signalbuf_t *sigBuf )

This function is similar to the dp_read_signal function. The difference is that it does not block waiting for incoming signaling states to change. It will return immediately with the current signalling data.

   int
   dp_write_signal (
        PCI_SIGNAL      *signal,
        dpt_signalbuf_t *sigBuf )

This function writes (sends) signaling data to the signaling channel. Application programs must declare and allocate the signal buffer and pass its address to the dp_read_signal function. The data to be sent is first written into the data array of the signaling buffer. The embedded code does not ensure that the new signalling data will be transmitted for all time slots during the same multi-frame.

The dp_write_signal function returns 0 when the data has been successfully sent to the channel or -1 in the case of an error. For example:

    PCI_SIGNAL       *signal
    dpt_signal_buf_t  sigbuf;

    signal = dp_open_signal(0, 1, CHAN_READ, 0xf) ;
    if (signal == NULL)
        error();
    sigbuf.data[0] = 1;
    sigbuf.data[1] = 2;
    sigbuf.data[2] = 3;
    sigbuf.data[3] = 4;
    if (dp_write_signal(signal) < 0)
        error();

DMA uploads are available for 8-bit and 32-bit words with the following restrictions:

• The source address on the DPT board must be within the SDRAM region.
• The source address on the DPT board must be long-word aligned (modulo-4).
• The number of bytes requested must be a multiple of 4.
• The maximum size of any single DMA request is 32 K-bytes.

The following functions are added to the API library providing application interface to the DMA capability:

   int
   pci_up_dma8b (
        PCI_MOD    *dpt,
        uint32_t   *addr,
        uint32_t    nbytes,
        uint8_t    *buf )

   int
   pci_up_dma32b (
        PCI_MOD    *dpt,
        uint32_t   *addr,
        uint32_t    nwords,
        uint32_t   *buf )

• device access
• memory mapping for programmed I/O
• interrupt handling

It does not yet provide capabilities for DMA transfers or channelization. The Linux device driver is still under development and a complete implementation will be available in the near future.

Currently the Linux device driver has been tested on Inel x86 platforms running Red-Hat Linux with Kernel versions 2.4.7-10 and 2.4.9-31. More information is provided in the Readme file in the linuxdev directory of the distribution.

To install the smPCI support files run the configure program with the new --enable-smpci option. For example:

     ../dpt-1.2.4/configure --enable-smpci

Using that option will copy the smPCI support files from the distribution directory to the proper directory of your target installation directory, e.g. /usr/cac/smpci.

A warning has been added when the dpflashup program is run and requires user confirmation to continue. It also sets a flag in the EEROM to detect when a power cycle is required after updating FPGA configuration data.

The dprun program has a new cold-reset option (-c) and can be used on mulitple boards for a single run. It may be used for all boards by using the keyword all for the device parameter.

The dpinfo program now works when a specific expansion module is named on the command line.

The dpclock program has a new -p option to specify an alternate directory path instead of what is in the $CAC environment variable. This is primarily for developement use.

DMA and array transfer test commands are added to the dpdebug program.

A new program called dpfind provides a quick listing of DPT boards installed and available in the system.

New sample programs: dpsnd and dpreceive in the "examples" directory of the distribution, provide simple examples of working with DPT channelization.

Programs in the "bin" directory of the distribution, dpsignaling and dpdmaxfer, provide examples of using the new signaling channels and the new DMA upload functions.

• Fixed checking for invalid T1 time slots in the dp_open_chan and dp_open_chanex functions.
• Fixed address translation problem with memory-mapped addresses.
• Added conditionally included code to avoid PCI burst downloads larger than 4 words for older systems with slow system bus speeds. (See the comments regarding BREAK_BURST in include/dp_options.h.)
• Added support in pci_tdm_src_add for framer status information to be routed to the TDM subsystem.
• Fixed potential problem detecting when the TDM bank has switched in the pci_tdm_updatemap and pci_tdm_run functions.
• Fixed flash file search directory error detection and messages.

• Fixed problem with burst transfers from the host to expansion modules.
• Fixed problem with burst transfers from expansion modules to SDRAM on the base-board.
• Fixed problem with host reading Comet and H.100 registers.
• DMA transfer from base-board SDRAM to host now supports a minimum transfer size of 1 word.

The smPCI Expansion FPGA configuration includes the following changes:

• Fixed problem with burst writes from expansion modules to SDRAM on the base-board.
• Fixed data transfer access between processors on smPCI modules and SDRAM on the DPT base-board.