module implements the core of llcontrol loop. More...

#include "local.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <popt.h>
#include "acq32ioctl.h"
#include "acq32busprot.h"
#include "llif.h"
#include "llprotocol.h"
#include "llcontrol.h"
#include "x86timer.h"
#include "llcontrol-core.h"
#include <signal.h>

Defines
#define	FLAVOR "ACQ32"
#define	EACHMFA (dac_buf[icard].mfa)
#define	EACHBBB (dac_buf[icard].bbb)
#define	EACHDAC_BASE (EACHBBB + EACHMFA)
#define	EACHDAC_BASE16 ((u16*)EACHDAC_BASE)
#define	NMEASURE 20
Functions
static void	mbox_updateTstats (u32 cmd, struct Card card, struct TimingStats tstats)
	update timing stats from card mailbox.
void	v2_updateTstats (u32 cmd, struct Card card, struct TimingStats tstats)
	updates timing stats from embedded host buffer data
void	doApplicationWork (struct TestDescription *td, u32 offset)
static u32	card_v1_WaitDmaDone (struct Card *card)
u32	card_v2_WaitDmaDone (struct Card *card)
	updates timing stats from embedded host buffer data
static int	do_run (struct TestDescription *td, int soft_clock)
	runs the test.
static int	runSCM (struct TestDescription *td)
	Run a Test - Soft Clock Master.
static int	runECM (struct TestDescription *td)
	Run a Test - External Clock Master.
u32	commandModifiers (struct TestDescription *td)
static int	measureBridge (struct MU *mu)
	Run a test - measureBridge performance.
static int	measureBridgeStats (struct TestDescription td, struct MU mu)
int	runTest (struct TestDescription *td)
	generic top level text exec.
static void	quit_handler (int signum)
void	setupAbortHandler (struct TestDescription *td)
static void	monitor_handler (int signum)
void	setupMonitor (int millisec)
void	initCardResource (struct Card *card)
static void	debug_prompt (int icard, int ibuf, u32 addr)
	promnpt user to ensure pram set (temporary pre-update measure).
void	initV2Stats (struct TestDescription *td)
Variables
const char *	core_ident = "$Revision: 1.1.4.33 $ B1102\n"
void(*	updateTstats )(u32 cmd, struct Card card, struct TimingStats tstats)
	virtual function to retrieve timing stats.
u32(*	waitDmaDone )(struct Card *c) = card_v1_WaitDmaDone
	virtual function to block until DMA done.
int	user_abort = 0
static struct TestDescription *	S_td

Detailed Description

module implements the core of llcontrol loop.

mmapMboxes() - get app mapping for mailboxes

mmapBuffer() - get dmabuff and phys addresses

runSCM() - capture using soft trigger

runECM() - capture using external clock

Linux 2.4 Host Only:

2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4

Note on HOST MEMORY MAP: assumes bootcommand configured as follows, to allow a 16MB host area per card in at the top of memory. This host area will be slaved off the pci backplane

mem=NNN restrict memory for Linux. Must allow Nx16MB + gap
acq32_big_buf_base=0xnnnn : informs driver of start of area
acq32_big_buf_len=0xxxxx : informs driver of length of area

eg

[dt100 dt100]$ cat /proc/cmdline mem=320M acq32.load_order=slotbased

acq32_big_buf_base=0x18000000 acq32_big_buf_len=0x08000000

For the purpose of LLCONTROL, each 16MB card are is used as follows:

0x000000 .. 0xefffff (15MB) - AI reception area (controlled by client app).
0xf00000 .. 0xffffff (1MB) - message buffers (owned by target).

2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4 2.4

This means that if the llcontrol app is using an incrementing memory strategy in host buffer for AI, this is subject to max 15MB (80K samples at 96 channels).

The message buffers are used for DAC output. The application reserves a Mesage Frame Address (MFA) from the target before copying data to slave memory. The MFA is an index into the message buffer memory.

Linux 2.6 Host:

the host buffer is setup dynamically, but is LIMITED to 4MB, of which the top 1M is used for messaging.

Definition in file llcontrol-core.c.

Define Documentation

#define EACHBBB (dac_buf[icard].bbb)

#define EACHDAC_BASE (EACHBBB + EACHMFA)

Referenced by do_run(), runSYNC_2V(), runSYNC_2VAO32(), and runSYNC_ECM().

#define EACHDAC_BASE16 ((u16*)EACHDAC_BASE)

Referenced by do_run(), runSYNC_2V(), runSYNC_2VAO32(), and runSYNC_ECM().

#define EACHMFA (dac_buf[icard].mfa)

Referenced by do_run().

#define FLAVOR "ACQ32"

Definition at line 226 of file llcontrol-core.c.

#define NMEASURE 20

Referenced by measureBridge().

Function Documentation

static u32 card_v1_WaitDmaDone ( struct Card * card ) [static]

Definition at line 292 of file llcontrol-core.c.

References llWaitDmaDone(), and Card::mbx.

u32 card_v2_WaitDmaDone ( struct Card * card )

updates timing stats from embedded host buffer data

Definition at line 297 of file llcontrol-core.c.

References Card::buf, getVaddr(), LLCV2_OFFSET_STATUS_HSBT, llv2WaitDmaDone(), and Card::mbx.

u32 commandModifiers ( struct TestDescription * td )

Definition at line 553 of file llcontrol-core.c.

References LLCV2_INIT_MAGIC_MARKER, LLCV2_INIT_MARKER, and TestDescription::V2_BUFS.

Referenced by appEnterLLC_SYNC_2V(), appEnterLLC_SYNC_ECM(), and runTest().

static void debug_prompt	(	int	icard,
		int	ibuf,
		u32	addr
	)			`[static]`

promnpt user to ensure pram set (temporary pre-update measure).

Definition at line 862 of file llcontrol-core.c.

Referenced by initV2Stats().

static int do_run	(	struct TestDescription *	td,
		int	soft_clock
	)			`[static]`

runs the test.

Todo:: could be set by a signal

PSEUDO-CODE:

(1) Clear the latch timer
(2) Set a local memory target address and arm the capture
(3) Poll for counter running (hardware counter starts on external gate)
(4) Iterate for required number of samples:
(5) [optionally send a soft clock command] trigger an acquisition
(6) Wait for DMA Done - at this point data is available in target mem. A "real" control application is probably getting most of its calcs done here rather than simply polling
(7) [Get the latch (sample) and current uSec counters from the boards - only if interested]
(8) Check the process has not stopped (external gate high)
(9) [optionally update the target address - else it gets overwritten]
(a) using DACS - preallocate a MFA for dac data.
(b) write data to host side buffer(f(MFA)) and post MFA
(b.1) take the incoming value on feedback_channel and propagate to all DACS. default is to assume HAWG on DAC0 (so feedback_channel better be 0 !), but td->update_dacs makes a better test.
(b.15) special case where we are DRIVING the initial DAC signal from host side.
(b.2) simple feedforward case - just drive all DACS from AWG pattern.