dma.h File Reference

#include <tamtypes.h>
#include <packet2_types.h>

Include dependency graph for dma.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	DMA_CHANNEL_VIF0   0x00
#define	DMA_CHANNEL_VIF1   0x01
#define	DMA_CHANNEL_GIF   0x02
#define	DMA_CHANNEL_fromIPU   0x03
#define	DMA_CHANNEL_toIPU   0x04
#define	DMA_CHANNEL_fromSIF0   0x05
#define	DMA_CHANNEL_toSIF1   0x06
#define	DMA_CHANNEL_SIF2   0x07
#define	DMA_CHANNEL_fromSPR   0x08
#define	DMA_CHANNEL_toSPR   0x09
#define	DMA_FLAG_TRANSFERTAG   0x01
#define	DMA_FLAG_INTERRUPTSAFE   0x02

Functions
int	dma_reset (void)
int	dma_channel_initialize (int channel, void *handler, int flags)
void	dma_channel_fast_waits (int channel)
void	dma_wait_fast (void)
int	dma_channel_wait (int channel, int timeout)
void	dma_channel_send_packet2 (packet2_t *packet2, int channel, u8 flush_cache)
int	dma_channel_send_chain (int channel, void *data, int qwc, int flags, int spr)
int	dma_channel_send_chain_ucab (int channel, void *data, int qwc, int flags)
int	dma_channel_send_normal (int channel, void *data, int qwc, int flags, int spr)
int	dma_channel_send_normal_ucab (int channel, void *data, int qwc, int flags)
int	dma_channel_receive_normal (int channel, void *data, int data_size, int flags, int spr)
int	dma_channel_receive_chain (int channel, void *data, int data_size, int flags, int spr)
int	dma_channel_shutdown (int channel, int flags)

Detailed Description

DMA channel utilities

Definition in file dma.h.

Macro Definition Documentation

DMA_CHANNEL_fromIPU

#define DMA_CHANNEL_fromIPU   0x03

Definition at line 25 of file dma.h.

DMA_CHANNEL_fromSIF0

#define DMA_CHANNEL_fromSIF0   0x05

Definition at line 27 of file dma.h.

DMA_CHANNEL_fromSPR

#define DMA_CHANNEL_fromSPR   0x08

Definition at line 30 of file dma.h.

DMA_CHANNEL_GIF

#define DMA_CHANNEL_GIF   0x02

Definition at line 24 of file dma.h.

DMA_CHANNEL_SIF2

#define DMA_CHANNEL_SIF2   0x07

Definition at line 29 of file dma.h.

DMA_CHANNEL_toIPU

#define DMA_CHANNEL_toIPU   0x04

Definition at line 26 of file dma.h.

DMA_CHANNEL_toSIF1

#define DMA_CHANNEL_toSIF1   0x06

Definition at line 28 of file dma.h.

DMA_CHANNEL_toSPR

#define DMA_CHANNEL_toSPR   0x09

Definition at line 31 of file dma.h.

DMA_CHANNEL_VIF0

#define DMA_CHANNEL_VIF0   0x00

Definition at line 22 of file dma.h.

DMA_CHANNEL_VIF1

#define DMA_CHANNEL_VIF1   0x01

Definition at line 23 of file dma.h.

DMA_FLAG_INTERRUPTSAFE

#define DMA_FLAG_INTERRUPTSAFE   0x02

Definition at line 34 of file dma.h.

DMA_FLAG_TRANSFERTAG

#define DMA_FLAG_TRANSFERTAG   0x01

Definition at line 33 of file dma.h.

Function Documentation

dma_channel_fast_waits()

void dma_channel_fast_waits

(

int

channel

)

Enables dma fast waits for that channel

Definition at line 108 of file dma.c.

{
 
        *DMA_REG_PCR |= 1 << channel;
 
}

References DMA_REG_PCR.

Referenced by main().

dma_channel_initialize()

int dma_channel_initialize	(	int	channel,
		void *	handler,
		int	flags
	)

Initializes the specified dma channel.

Definition at line 58 of file dma.c.

{
 
        // Shut down the channel before making changes.
        if (dma_channel_shutdown(channel, flags) < 0)
        {
                return -1;
        }
 
        // Clear any saved dmatags
        if (dma_asr0[channel])
        {
                *(vu32 *)dma_asr0[channel] = 0;
                *(vu32 *)dma_asr1[channel] = 0;
        }
 
        // Clear saved spr address
        if (dma_sadr[channel])
        {
                *(vu32 *)dma_sadr[channel] = 0;
        }
 
        // If a handler is provided...
        if (handler != NULL)
        {
 
        // Add the handler, storing the handler id.
        dma_handler_id[channel] = AddDmacHandler(channel, handler, 0);
 
        // Enable the channel interrupt.
                if (flags & DMA_FLAG_INTERRUPTSAFE)
                {
                        iEnableDmac(channel);
                }
                else
                {
                        EnableDmac(channel);
                }
 
        }
 
        // Tell everyone we are initialized.
        dma_channel_initialized[channel] = 1;
 
        // End function.
        return 0;
 
}

References AddDmacHandler(), dma_asr0, dma_asr1, dma_channel_initialized, dma_channel_shutdown(), DMA_FLAG_INTERRUPTSAFE, dma_handler_id, dma_sadr, EnableDmac(), iEnableDmac(), and NULL.

Referenced by dma_channel_receive_chain(), dma_channel_receive_normal(), and main().

dma_channel_receive_chain()

int dma_channel_receive_chain	(	int	channel,
		void *	data,
		int	data_size,
		int	flags,
		int	spr
	)

Receive data from the specified dma channel.

Definition at line 296 of file dma.c.

{
 
        // If we are not initialized...
        if (dma_channel_initialized[channel] < 0)
        {
 
                // Initialize the channel.
                if (dma_channel_initialize(channel, NULL, flags) < 0)
                {
                        return -1;
                }
 
        }
 
        // Set the size of the data, in quadwords.
        *(vu32 *)dma_qwc[channel] = DMA_SET_QWC((data_size + 15) >> 4);
 
        // Set the address of the data.
        *(vu32 *)dma_madr[channel] = DMA_SET_MADR((u32)data, spr);
 
        // Start the transfer.
        *(vu32 *)dma_chcr[channel] = DMA_SET_CHCR(0, 1, 0, 0, 0, 1, 0);
 
        // End function.
        return 0;
 
}

References data, dma_channel_initialize(), dma_channel_initialized, dma_chcr, dma_madr, dma_qwc, DMA_SET_CHCR, DMA_SET_MADR, DMA_SET_QWC, and NULL.

dma_channel_receive_normal()

int dma_channel_receive_normal	(	int	channel,
		void *	data,
		int	data_size,
		int	flags,
		int	spr
	)

Receive data from the specified dma channel.

Definition at line 325 of file dma.c.

{
 
        // If we are not initialized...
        if (dma_channel_initialized[channel] < 0)
        {
 
        // Initialize the channel.
                if (dma_channel_initialize(channel, NULL, flags) < 0)
                {
                        return -1;
                }
 
        }
 
        // Set the size of the data, in quadwords.
        *(vu32 *)dma_qwc[channel] = DMA_SET_QWC((data_size + 15) >> 4);
 
        // Set the address of the data.
        *(vu32 *)dma_madr[channel] = DMA_SET_MADR((u32)data, spr);
 
        // Start the transfer.
        *(vu32 *)dma_chcr[channel] = DMA_SET_CHCR(0, 0, 0, 0, 0, 1, 0);
 
        // End function.
        return 0;
 
}

References data, dma_channel_initialize(), dma_channel_initialized, dma_chcr, dma_madr, dma_qwc, DMA_SET_CHCR, DMA_SET_MADR, DMA_SET_QWC, and NULL.

dma_channel_send_chain()

int dma_channel_send_chain	(	int	channel,
		void *	data,
		int	qwc,
		int	flags,
		int	spr
	)

Send a dmachain to the specified dma channel.

Definition at line 184 of file dma.c.

{
 
        // clear channel status
        *DMA_REG_STAT = DMA_SET_STAT(1 << channel,0,0,0,0,0,0);
 
        if (flags & DMA_FLAG_INTERRUPTSAFE)
        {
                iSyncDCache(data, data + (data_size<<4));
        }
        else
        {
                SyncDCache(data, data + (data_size<<4));
        }
 
        // Set the size of the data, in quadwords.
        *(vu32 *)dma_qwc[channel] = DMA_SET_QWC(0);
 
        // Set the address of the data.
        *(vu32 *)dma_madr[channel] = DMA_SET_MADR(0, 0);
 
        // Set the address of the data tag.
        *(vu32 *)dma_tadr[channel] = DMA_SET_TADR((u32)data, spr);
 
        // Start the transfer.
        *(vu32 *)dma_chcr[channel] = DMA_SET_CHCR(1, 1, 0, flags & DMA_FLAG_TRANSFERTAG, 1, 1, 0);
 
        return 0;
 
}

References data, dma_chcr, DMA_FLAG_INTERRUPTSAFE, DMA_FLAG_TRANSFERTAG, dma_madr, dma_qwc, DMA_REG_STAT, DMA_SET_CHCR, DMA_SET_MADR, DMA_SET_QWC, DMA_SET_STAT, DMA_SET_TADR, dma_tadr, iSyncDCache(), and SyncDCache().

Referenced by dma_channel_send_packet2(), init_texture(), load_texture(), main(), and render().

dma_channel_send_chain_ucab()

int dma_channel_send_chain_ucab	(	int	channel,
		void *	data,
		int	qwc,
		int	flags
	)

Send a ucab dmachain to the specified dma channel.

Definition at line 215 of file dma.c.

{
 
        // clear channel status
        *DMA_REG_STAT = 1 << channel;
 
        // Set the size of the data, in quadwords.
        *(vu32 *)dma_qwc[channel] = DMA_SET_QWC(0);
 
        // Set the address of the data.
        *(vu32 *)dma_madr[channel] = DMA_SET_MADR(0, 0);
 
        // Set the address of the data tag.
        *(vu32 *)dma_tadr[channel] = DMA_SET_TADR((u32)data - 0x30000000, 0);
 
        // Start the transfer.
        *(vu32 *)dma_chcr[channel] = DMA_SET_CHCR(1, 1, 0, flags & DMA_FLAG_TRANSFERTAG, 1, 1, 0);
 
        // End function.
        return 0;
 
}

References data, dma_chcr, DMA_FLAG_TRANSFERTAG, dma_madr, dma_qwc, DMA_REG_STAT, DMA_SET_CHCR, DMA_SET_MADR, DMA_SET_QWC, DMA_SET_TADR, and dma_tadr.

dma_channel_send_normal()

int dma_channel_send_normal	(	int	channel,
		void *	data,
		int	qwc,
		int	flags,
		int	spr
	)

Send data to the specified dma channel.

Definition at line 238 of file dma.c.

{
 
        // clear channel status
        *DMA_REG_STAT = DMA_SET_STAT(1 << channel,0,0,0,0,0,0);
 
        // Not sure if this should be here.
        if (flags & DMA_FLAG_INTERRUPTSAFE)
        {
                iSyncDCache(data, data + (qwc<<4));
        }
        else
        {
                SyncDCache(data, data + (qwc<<4));
        }
 
        // Set the size of the data, in quadwords.
        *(vu32 *)dma_qwc[channel] = DMA_SET_QWC(qwc);
 
        // Set the address of the data.
        *(vu32 *)dma_madr[channel] = DMA_SET_MADR((u32)data, spr);
 
        // Start the transfer.
        *(vu32 *)dma_chcr[channel] = DMA_SET_CHCR(1, 0, 0, flags & DMA_FLAG_TRANSFERTAG, 1, 1, 0);
 
        return 0;
 
}

References data, dma_chcr, DMA_FLAG_INTERRUPTSAFE, DMA_FLAG_TRANSFERTAG, dma_madr, dma_qwc, DMA_REG_STAT, DMA_SET_CHCR, DMA_SET_MADR, DMA_SET_QWC, DMA_SET_STAT, iSyncDCache(), and SyncDCache().

Referenced by dma_channel_send_packet2(), draw_init_env(), init_drawing_environment(), main(), render(), run_demo(), SetDMA(), and setup_texture().

dma_channel_send_normal_ucab()

int dma_channel_send_normal_ucab	(	int	channel,
		void *	data,
		int	qwc,
		int	flags
	)

Send ucab data to the specified dma channel.

Definition at line 267 of file dma.c.

{
 
        // clear channel status
        *DMA_REG_STAT = DMA_SET_STAT(1 << channel,0,0,0,0,0,0);
 
        // Not sure if this should be here.
        if (flags & DMA_FLAG_INTERRUPTSAFE)
        {
                iSyncDCache(data, data + (qwc<<4));
        }
        else
        {
                SyncDCache(data, data + (qwc<<4));
        }
 
        // Set the size of the data, in quadwords.
        *(vu32 *)dma_qwc[channel] = DMA_SET_QWC(qwc);
 
        // Set the address of the data.
        *(vu32 *)dma_madr[channel] = DMA_SET_MADR((u32)data - 0x30000000, 0);
 
        // Start the transfer.
        *(vu32 *)dma_chcr[channel] = DMA_SET_CHCR(1, 0, 0, flags & DMA_FLAG_TRANSFERTAG, 1, 1, 0);
 
        return 0;
 
}

References data, dma_chcr, DMA_FLAG_INTERRUPTSAFE, DMA_FLAG_TRANSFERTAG, dma_madr, dma_qwc, DMA_REG_STAT, DMA_SET_CHCR, DMA_SET_MADR, DMA_SET_QWC, DMA_SET_STAT, iSyncDCache(), and SyncDCache().

Referenced by flip_buffers().

dma_channel_send_packet2()

void dma_channel_send_packet2	(	packet2_t *	packet2,
		int	channel,
		u8	flush_cache
	)

Send packet2. Type chain/normal is choosen from packet2_t.

Parameters

packet2	Pointer to packet.
channel	DMA channel.
flush_cache	Should be cache flushed before send?

Definition at line 157 of file dma.c.

{
        // dma_channel_send_chain does NOT flush all data that is "source chained"
        if (packet2->mode == P2_MODE_CHAIN)
        {
                // "dma_channel_send_normal always flushes the data cache"
                if (flush_cache)
                        FlushCache(0);
                dma_channel_send_chain(
                        channel,
                        (void *)((u32)packet2->base & 0x0FFFFFFF),
                        0,
                        packet2->tte ? DMA_FLAG_TRANSFERTAG : 0,
                        0);
        }
        else
        {
                dma_channel_send_normal(
                        channel,
                        (void *)((u32)packet2->base & 0x0FFFFFFF),              // make ptr normal
                        ((u32)packet2->next - (u32)packet2->base) >> 4, // length in qwords
                        0,
                        0);
        }
}

References packet2_t::base, dma_channel_send_chain(), dma_channel_send_normal(), DMA_FLAG_TRANSFERTAG, FlushCache(), packet2_t::mode, packet2_t::next, P2_MODE_CHAIN, and packet2_t::tte.

Referenced by clear_screen(), draw_cube(), init_drawing_environment(), send_texture(), vu1_set_double_buffer_settings(), and vu1_upload_micro_program().

dma_channel_shutdown()

int dma_channel_shutdown	(	int	channel,
		int	flags
	)

Shut down the specified dma channel.

Definition at line 354 of file dma.c.

{
 
        // If we are not initialized, no need to shut down.
        if (dma_channel_initialized[channel] < 0)
        {
                return 0;
        }
 
        // If a handler was provided...
        if (dma_handler_id[channel] != 0)
        {
 
        // Disable the channel.
                if (flags & DMA_FLAG_INTERRUPTSAFE)
                {
                        iDisableDmac(channel);
                }
                else
                {
                        DisableDmac(channel);
                }
 
                // Remove the handler.
                RemoveDmacHandler(channel, dma_handler_id[channel]);
 
                // Clear the handler id.
                dma_handler_id[channel] = 0;
 
        }
 
        // Tell everyone we are not initialized.
        dma_channel_initialized[channel] = 0;
 
        // End function.
        return 0;
 
}

References DisableDmac(), dma_channel_initialized, DMA_FLAG_INTERRUPTSAFE, dma_handler_id, iDisableDmac(), and RemoveDmacHandler().

Referenced by dma_channel_initialize(), dma_reset(), and main().

dma_channel_wait()

int dma_channel_wait	(	int	channel,
		int	timeout
	)

Wait until the specified dma channel is ready.

Definition at line 130 of file dma.c.

{
 
        // While the channel is not ready...
        while (*((vu32 *)dma_chcr[channel]) & 0x00000100)
        {
 
                // Decrement the timeout counter, exiting if it expires.
                if (timeout > 0)
                {
 
                        if (timeout-- == 0)
                        {
 
                                return -1;
 
                        };
 
                }
 
        }
 
        // End function.
        return 0;
 
}

References dma_chcr.

Referenced by draw_cube(), SetDMA(), vu1_set_double_buffer_settings(), and vu1_upload_micro_program().

dma_reset()

int dma_reset

(

void

)

Definition at line 40 of file dma.c.

{
 
        int i;
 
        for(i = 0; i < 10; i++)
        {
 
                dma_channel_shutdown(i,0);
 
        }
 
        ResetEE(0x01);
 
        return 0;
 
}

References dma_channel_shutdown(), and ResetEE().

dma_wait_fast()

void dma_wait_fast

(

void

)

Waits until channel is usable based on coprocessor status

Definition at line 115 of file dma.c.

{
 
        asm volatile (
                "sync.l; sync.p;" \
                "0:" \
                "bc0t 0f; nop;" \
                "bc0t 0f; nop;" \
                "bc0t 0f; nop;" \
                "bc0f 0b; nop;" \
                "0:"
        );
 
}

Referenced by clear_screen(), draw_init_env(), flip_buffers(), init_drawing_environment(), init_texture(), load_texture(), main(), render(), run_demo(), send_texture(), and setup_texture().