User guide
Table Of Contents
- Contents
- 1. About This MegaCore Function Suite
- Release Information
- Device Family Support
- Features
- Design Example
- Performance and Resource Utilization
- 2D FIR Filter
- 2D Median Filter
- Alpha Blending Mixer
- Avalon-ST Video Monitor
- Chroma Resampler
- Clipper
- Clocked Video Input
- Clocked Video Output
- Color Plane Sequencer
- Color Space Converter
- Control Synchronizer
- Deinterlacer
- Deinterlacer II
- Frame Buffer
- Gamma Corrector
- Interlacer
- Scaler
- Scaler II
- Switch
- Test Pattern Generator
- Trace System
- 2. Getting Started with Altera IP Cores
- 3. Interfaces
- Interface Types
- Avalon-ST Video Protocol
- Avalon-MM Slave Interfaces
- Avalon-MM Master Interfaces
- Buffering of Non-Image Data Packets in Memory
- 4. 2D FIR Filter MegaCore Function
- 5. 2D Median Filter MegaCore Function
- 6. Alpha Blending MegaCore Function
- 7. Avalon-ST Video Monitor MegaCore Function
- 8. Chroma Resampler MegaCore Function
- 9. Clipper MegaCore Function
- 10. Clocked Video Input MegaCore Function
- 11. Clocked Video Output MegaCore Function
- 12. Color Plane Sequencer MegaCore Function
- 13. Color Space Converter MegaCore Function
- 14. Control Synchronizer MegaCore Function
- 15. Deinterlacer MegaCore Function
- Core Overview
- Functional Description
- Parameter Settings
- Signals
- Control Register Maps
- 16. Deinterlacer II MegaCore Function
- 17. Frame Reader MegaCore Function
- 18. Frame Buffer MegaCore Function
- 19. Gamma Corrector MegaCore Function
- 20. Interlacer MegaCore Function
- 21. Scaler MegaCore Function
- 22. Scaler II MegaCore Function
- 23. Switch MegaCore Function
- 24. Test Pattern Generator MegaCore Function
- 25. Trace System MegaCore Function
- A. Avalon-ST Video Verification IP Suite
- B. Choosing the Correct Deinterlacer
- Additional Information

Chapter 3: Interfaces 3–17
Avalon-MM Slave Interfaces
January 2013 Altera Corporation Video and Image Processing Suite
User Guide
Avalon-MM Slave Interfaces
The Video and Image Processing Suite MegaCore functions that permit run-time
control of some aspects of their behavior, use a common type of Avalon-MM slave
interface for this purpose.
Each slave interface provides access to a set of control registers which must be set by
external hardware. You must assume that these registers power up in an undefined
state. The set of available control registers and the width in binary bits of each register
varies with each control interface.
1 For a description of the control registers for each MegaCore function, refer to the
“Control Register Map” section of the respective MegaCore Function chapter in this
user guide.
The first two registers of every control interface perform the following two functions
(the others vary with each control interface):
■ Register 0 is the
Go
register. Bit zero of this register is the
Go
bit. A few cycles after
the function comes out of reset, it writes a zero in the
Go
bit (remember that all
registers in Avalon-MM control slaves power up in an undefined state).
Although there are a few exceptions, most Video and Image Processing Suite
MegaCore functions stop at the beginning of an image data packet if the
Go
bit is
set to 0. This allows you to stop the MegaCore function and to program run-time
control data before the processing of the image data begins. A few cycles after the
Go
bit is set by external logic connected to the control port, the MegaCore function
begins processing image data. If the
Go
bit is unset while data is being processed,
then the MegaCore function stops processing data again at the beginning of the
next image data packet and waits until the Go bit is set by external logic.
■ Register 1 is the
Status
register. Bit zero of this register is the
Status
bit, the
function does not use all other bits. The function sets the
Status
bit to 1 when it is
running, and zero otherwise. External logic attached to the control port must not
attempt to write to the
Status
register.
The following pseudo-code illustrates the design of functions that double-buffer their
control (that is, all MegaCore functions except the Gamma Corrector and some Scaler
parameterizations):
go = 0;
while (true)
{
read_non_image_data_packets();
status = 0;
while (go != 1)
wait;
read_control(); // Copies control to internal registers
status = 1;
send_image_data_header();
process_frame();
}
For MegaCore functions that do not double buffer their control data, the algorithm
described in the previous paragraph is still largely applicable but the changes to the
control register will affect the current frame.