/*************************************************************************
 *
 *  File: iomap.h
 *
 *  This file contains definitions for all I/O address segments and 
 *  registers.
 *
 *  $Header: /root/leakn64/depot/rf/sw/n64os20l/iosim/src/iomap.h,v 1.2 2002/05/30 05:52:53 whs Exp $
 *
 */

#ifndef _IO_MAP_H_
#define _IO_MAP_H_

/*
 * NOTE: The information presented in this file is extracted from the
 *	 document PR/doc/memory_map (version 1.17)
 */

/*
Here is a quick overview of the (known) address map:

RCP memory map:

0x0000_0000 .. 0x03ef_ffff	RDRAM memory
0x03f0_0000 .. 0x03ff_ffff	RDRAM registers
0x0400_0000 .. 0x040f_ffff	SP registers
0x0410_0000 .. 0x041f_ffff	DP command registers
0x0420_0000 .. 0x042f_ffff	DP span registers
0x0430_0000 .. 0x043f_ffff	MI registers
0x0440_0000 .. 0x044f_ffff	VI registers
0x0450_0000 .. 0x045f_ffff	AI registers
0x0460_0000 .. 0x046f_ffff	PI registers
0x0470_0000 .. 0x047f_ffff	RI registers
0x0480_0000 .. 0x048f_ffff	SI registers
0x0490_0000 .. 0x04ff_ffff	unused
0x0500_0000 .. 0x05ff_ffff	cartridge domain 2
0x0600_0000 .. 0x07ff_ffff	cartridge domain 1
0x0800_0000 .. 0x0fff_ffff	cartridge domain 2
0x1000_0000 .. 0x1fbf_ffff	cartridge domain 1
0x1fc0_0000 .. 0x1fcf_ffff	PIF ROM
0x1fd0_0000 .. 0xffff_ffff	cartridge domain 1

*/

/*************************************************************************
 * Segment base addresses and sizes
 */
#define KUBASE          0
#define KUSIZE          0x80000000
#define K0BASE          0x80000000
#define K0SIZE          0x20000000
#define K1BASE          0xA0000000
#define K1SIZE          0x20000000
#define K2BASE          0xC0000000
#define K2SIZE          0x20000000

#define PHYS_TO_K0(x)   ((unsigned)(x)|0x80000000)      /* physical to kseg0 */
#define PHYS_TO_K1(x)	(0xA0000000 | (x))
#define K0_TO_PHYS(x)	((unsigned)(x)&0x1FFFFFFF)	/* kseg0 to physical */
#define K1_TO_PHYS(x)	((unsigned)(x)&0x1FFFFFFF)	/* kseg1 to physical */

/*
 * Address predicates
 */
#define IS_KSEG0(x)     ((unsigned)(x) >= K0BASE && (unsigned)(x) < K1BASE)
#define IS_KSEG1(x)     ((unsigned)(x) >= K1BASE && (unsigned)(x) < K2BASE)


/*************************************************************************
 * RDRAM Memory
 */
#define RDRAM_0_START		0x00000000
#define RDRAM_0_END		0x001FFFFF
#define RDRAM_1_START		0x00200000
#define RDRAM_1_END		0x003FFFFF

#define RDRAM_START		RDRAM_0_START
#define RDRAM_END		RDRAM_1_END

/*************************************************************************
 * RDRAM Registers (0x03f0_0000 .. 0x03ff_ffff)
 */
#define RDRAM_BASE_REG		0x03F00000

#define RDRAM_CONFIG_REG	(RDRAM_BASE_REG+0x00)
#define RDRAM_DEVICE_TYPE_REG	(RDRAM_BASE_REG+0x00)
#define RDRAM_DEVICE_ID_REG	(RDRAM_BASE_REG+0x04)
#define RDRAM_DELAY_REG		(RDRAM_BASE_REG+0x08)
#define RDRAM_MODE_REG		(RDRAM_BASE_REG+0x0c)
#define RDRAM_REF_INTERVAL_REG	(RDRAM_BASE_REG+0x10)
#define RDRAM_REF_ROW_REG	(RDRAM_BASE_REG+0x14)
#define RDRAM_RAS_INTERVAL_REG	(RDRAM_BASE_REG+0x18)
#define RDRAM_MIN_INTERVAL_REG	(RDRAM_BASE_REG+0x1c)
#define RDRAM_ADDR_SELECT_REG	(RDRAM_BASE_REG+0x20)
#define RDRAM_DEVICE_MANUF_REG	(RDRAM_BASE_REG+0x24)

#define RDRAM_0_DEVICE_ID	0
#define RDRAM_1_DEVICE_ID	1

#define RDRAM_RESET_MODE        0
#define RDRAM_ACTIVE_MODE       1
#define RDRAM_STANDBY_MODE      2

#define RDRAM_LENGTH		(2*512*2048)
#define RDRAM_0_BASE_ADDRESS	(RDRAM_0_DEVICE_ID*RDRAM_LENGTH)
#define RDRAM_1_BASE_ADDRESS	(RDRAM_1_DEVICE_ID*RDRAM_LENGTH)

#define RDRAM_0_CONFIG		0x00000
#define RDRAM_1_CONFIG		0x00800
#define RDRAM_GLOBAL_CONFIG	0x80000


/*************************************************************************
 * PIF Physical memory map (total size = 2 KB)
 *
 *			  Size	    Description
 *	1FC007FF	+-------+-----------------+-----+
 *			|  64 B |   Buffer RAM    | R/W |
 *	1FC007C0	+-------+-----------------+-----+
 *			|   4 B |   PIF status    |  R  |
 *	1FC007BC	+-------+-----------------+-----+
 *			|1980 B |    Boot ROM     |  R  |
 *	1FC00000	+-------+-----------------+-----+
 *
 */
#define PIF_ROM_START		0x1FC00000
#define PIF_ROM_END		0x1FCFFFFF


/*************************************************************************
 * SP Memory
 */
#define SP_DMEM_START		0x04000000	/* read/write */
#define SP_DMEM_END		0x04000FFF
#define SP_IMEM_START		0x04001000	/* read/write */
#define SP_IMEM_END		0x04001FFF

/*************************************************************************
 * SP CP0 Registers
 */

#define SP_BASE_REG		0x04040000

/* SP memory address (R/W): [11:0] DMEM/IMEM address; [12] 0=DMEM,1=IMEM */
#define SP_MEM_ADDR_REG		(SP_BASE_REG+0x00)	/* Master */
						
/* SP DRAM DMA address (R/W): [23:0] RDRAM address */
#define SP_DRAM_ADDR_REG	(SP_BASE_REG+0x04)	/* Slave */

/* SP read DMA length (R/W): [11:0] length, [19:12] count, [31:20] skip */
/* direction: I/DMEM <- RDRAM */
#define SP_RD_LEN_REG		(SP_BASE_REG+0x08)	/* R/W: read len */

/* SP write DMA length (R/W): [11:0] length, [19:12] count, [31:20] skip */
/* direction: I/DMEM -> RDRAM */
#define SP_WR_LEN_REG		(SP_BASE_REG+0x0C)	/* R/W: write len */

/* SP status (R/W): [6:0] valid bits; see below for write/read mode */
#define SP_STATUS_REG		(SP_BASE_REG+0x10)

/* SP DMA full (R): [0] valid bit; dma full */
#define SP_DMA_FULL_REG		(SP_BASE_REG+0x14)

/* SP DMA busy (R): [0] valid bit; dma busy */
#define SP_DMA_BUSY_REG		(SP_BASE_REG+0x18)

/* SP semaphore (R/W): Read:  [0] semaphore flag (set on read) */
/*                     Write: [] clear semaphore flag */
#define SP_SEMAPHORE_REG	(SP_BASE_REG+0x1C)

/* SP PC (R/W): [11:0] program counter */
#define SP_PC_REG		0x04080000

/* SP IMEM BIST REG (R/W): [6:0] BIST status bits; see below for detail */
#define SP_IBIST_REG	0x04080004

/*
 * Values to set in DMA DRAM address reg (SP_DRAM_ADDR_REG)
 *	Bit [11:0] DMEM/IMEM address
 *	Bit [12]   0 = DMEM; 1 = IMEM
 */
#define SP_DMA_DMEM		0x0000		/* Bit 12: 0=DMEM, 1=IMEM */
#define SP_DMA_IMEM		0x1000		/* Bit 12: 0=DMEM, 1=IMEM */

/*
 * Values to clear/set bit in status reg (SP_STATUS_REG - write)
 */
#define SP_CLR_HALT		0x00001	    /* Bit  0: clear halt */
#define SP_SET_HALT		0x00002	    /* Bit  1: set halt */
#define SP_CLR_BROKE		0x00004	    /* Bit  2: clear broke */
#define SP_CLR_INTR		0x00008	    /* Bit  3: clear intr */
#define SP_SET_INTR		0x00010	    /* Bit  4: set intr */
#define SP_CLR_SSTEP		0x00020	    /* Bit  5: clear sstep */
#define SP_SET_SSTEP		0x00040	    /* Bit  6: set sstep */
#define SP_CLR_SIG0		0x00080	    /* Bit  7: clear signal 0 */
#define SP_SET_SIG0		0x00100	    /* Bit  8: set signal 0 */
#define SP_CLR_SIG1		0x00200	    /* Bit  9: clear signal 1 */
#define SP_SET_SIG1		0x00400	    /* Bit 10: set signal 1 */
#define SP_CLR_SIG2		0x00800	    /* Bit 11: clear signal 2 */
#define SP_SET_SIG2		0x01000	    /* Bit 12: set signal 2 */
#define SP_CLR_SIG3		0x02000	    /* Bit 13: clear signal 3 */
#define SP_SET_SIG3		0x04000	    /* Bit 14: set signal 3 */
#define SP_CLR_INTR_BREAK	0x08000	    /* Bit 15: clear intr on break */
#define SP_SET_INTR_BREAK	0x10000	    /* Bit 16: set intr on break */

/*
 * Patterns to interpret status reg (SP_STATUS_REG - read)
 */
#define SP_STATUS_HALT		0x001		/* Bit  0: halt */
#define SP_STATUS_BROKE		0x002		/* Bit  1: broke */
#define SP_STATUS_DMA_BUSY	0x004		/* Bit  2: dma busy */
#define SP_STATUS_DMA_FULL	0x008		/* Bit  3: dma full */
#define SP_STATUS_IO_FULL	0x010		/* Bit  4: io full */
#define SP_STATUS_SSTEP		0x020		/* Bit  5: single step */
#define SP_STATUS_SIG0		0x040		/* Bit  6: signal 0 set */
#define SP_STATUS_SIG1		0x080		/* Bit  7: signal 1 set */
#define SP_STATUS_SIG2		0x100		/* Bit  8: signal 2 set */
#define SP_STATUS_SIG3		0x200		/* Bit  9: signal 3 set */
#define SP_STATUS_INTR_BREAK	0x400		/* Bit 10: interrupt on break */

/*
 * Patterns to interpret status reg (SP_IMEM_BIST_REG - write)
 */
#define SP_IBIST_CHECK		0x01		/* Bit 0: BIST check */
#define SP_IBIST_GO		0x02		/* Bit 1: BIST go */
#define SP_IBIST_CLEAR		0x04		/* Bit 2: BIST clear */

/*
 * Patterns to interpret status reg (SP_IMEM_BIST_REG - read)
 */
/* First 2 bits are same as in write mode:  
 * Bit 0: BIST check; Bit 1: BIST go 
 */
#define SP_IBIST_DONE		0x04		/* Bit 2: BIST done */
#define SP_IBIST_FAILED		0x78		/* Bit [6:3]: BIST fail */


/*************************************************************************
 * DP Command Registers 
 */
#define DPC_BASE_REG		0x04100000

/* DP CMD DMA start (R/W): [23:0] DMEM/RDRAM start address */
#define DPC_START_REG		(DPC_BASE_REG+0x00)

/* DP CMD DMA end (R/W): [23:0] DMEM/RDRAM end address */
#define DPC_END_REG		(DPC_BASE_REG+0x04)

/* DP CMD DMA end (R): [23:0] DMEM/RDRAM current address */
#define DPC_CURRENT_REG		(DPC_BASE_REG+0x08)	

/* DP CMD status (R/W): [9:0] valid bits - see below for definitions */
#define DPC_STATUS_REG		(DPC_BASE_REG+0x0C)

/* DP clock counter (R): [23:0] clock counter */
#define DPC_CLOCK_REG		(DPC_BASE_REG+0x10)	

/* DP buffer busy counter (R): [23:0] clock counter */
#define DPC_BUFBUSY_REG		(DPC_BASE_REG+0x14)

/* DP pipe busy counter (R): [23:0] clock counter */
#define DPC_PIPEBUSY_REG	(DPC_BASE_REG+0x18)

/* DP TMEM load counter (R): [23:0] clock counter */
#define DPC_TMEM_REG		(DPC_BASE_REG+0x1C)

/*
 * Values to clear/set bit in status reg (DPC_STATUS_REG - write)
 */
#define DPC_CLR_XBUS_DMEM_DMA	0x0001		/* Bit 0: clear xbus_dmem_dma */
#define DPC_SET_XBUS_DMEM_DMA	0x0002		/* Bit 1: set xbus_dmem_dma */
#define DPC_CLR_FREEZE		0x0004		/* Bit 2: clear freeze */
#define DPC_SET_FREEZE		0x0008		/* Bit 3: set freeze */
#define DPC_CLR_FLUSH		0x0010		/* Bit 4: clear flush */
#define DPC_SET_FLUSH		0x0020		/* Bit 5: set flush */
#define DPC_CLR_TMEM_CTR	0x0040		/* Bit 6: clear tmem ctr */
#define DPC_CLR_PIPE_CTR	0x0080		/* Bit 7: clear pipe ctr */
#define DPC_CLR_CMD_CTR		0x0100		/* Bit 8: clear cmd ctr */
#define DPC_CLR_CLOCK_CTR	0x0200		/* Bit 9: clear clock ctr */

/*
 * Patterns to interpret status reg (DPC_STATUS_REG - read)
 */
#define DPC_STATUS_XBUS_DMEM_DMA	0x001	/* Bit  0: xbus_dmem_dma */
#define DPC_STATUS_FREEZE		0x002	/* Bit  1: freeze */
#define DPC_STATUS_FLUSH		0x004	/* Bit  2: flush */
#define DPC_STATUS_FROZEN		0x008	/* Bit  3: frozen */
#define DPC_STATUS_TMEM_BUSY		0x010	/* Bit  4: tmem busy */
#define DPC_STATUS_PIPE_BUSY		0x020	/* Bit  5: pipe busy */
#define DPC_STATUS_CMD_BUSY		0x040	/* Bit  6: cmd busy */
#define DPC_STATUS_CBUF_READY		0x080	/* Bit  7: cbuf ready */
#define DPC_STATUS_DMA_BUSY		0x100	/* Bit  8: dma busy */
#define DPC_STATUS_END_VALID		0x200	/* Bit  9: end valid */
#define DPC_STATUS_START_VALID		0x400	/* Bit 10: start valid */


/*************************************************************************
 * DP Span Registers 
 */
#define DPS_BASE_REG		0x04200000

/* DP tmem bist (R/W): [10:0] BIST status bits; see below for detail */
#define DPS_TBIST_REG		(DPS_BASE_REG+0x00)

/* DP span test mode (R/W): [0] Span buffer test access enable */
#define DPS_TEST_MODE_REG	(DPS_BASE_REG+0x04)

/* DP span buffer test address (R/W): [6:0] bits; see below for detail */
#define DPS_BUFTEST_ADDR_REG	(DPS_BASE_REG+0x08)

/* DP span buffer test data (R/W): [31:0] span buffer data */
#define DPS_BUFTEST_DATA_REG	(DPS_BASE_REG+0x0C)

/*
 * Patterns to interpret status reg (DPS_TMEM_BIST_REG - write)
 */
#define DPS_TBIST_CHECK		0x01		/* Bit 0: BIST check */
#define DPS_TBIST_GO		0x02		/* Bit 1: BIST go */
#define DPS_TBIST_CLEAR		0x04		/* Bit 2: BIST clear */

/*
 * Patterns to interpret status reg (DPS_TMEM_BIST_REG - read)
 */
/* First 2 bits are same as in write mode:  
 * Bit 0: BIST check; Bit 1: BIST go 
 */
#define DPS_TBIST_DONE		0x004		/* Bit 2: BIST done */
#define DPS_TBIST_FAILED	0x7F8		/* Bit [10:3]: BIST fail */


/*************************************************************************
 * MIPS Interface (MI) Registers 
 */
#define MI_BASE_REG		0x04300000

/* 
 * MI init mode (W): [6:0] init length, [7] clear init mode, [8] set init mode
 *                   [9/10] clear/set ebus test mode, [11] clear DP interrupt
 *              (R): [6:0] init length, [7] init mode, [8] ebus test mode
 */
#define MI_INIT_MODE_REG	(MI_BASE_REG+0x00)
#define MI_MODE_REG		MI_INIT_MODE_REG

/*
 * Values to clear/set bit in mode reg (MI_MODE_REG - write)
 */
#define MI_CLR_INIT		0x0080		/* Bit  7: clear init mode */
#define MI_SET_INIT		0x0100		/* Bit  8: set init mode */
#define MI_CLR_EBUS		0x0200		/* Bit  9: clear ebus test */
#define MI_SET_EBUS		0x0400		/* Bit 10: set ebus test mode */
#define MI_CLR_DP_INTR		0x0800		/* Bit 11: clear dp interrupt */
#define MI_CLR_RDRAM		0x1000		/* Bit 12: clear RDRAM reg */
#define MI_SET_RDRAM		0x2000		/* Bit 13: set RDRAM reg mode */

/*
 * Patterns to interpret mode reg (MI_MODE_REG - read)
 */
#define MI_MODE_INIT		0x0080		/* Bit  7: init mode */
#define MI_MODE_EBUS		0x0100		/* Bit  8: ebus test mode */
#define MI_MODE_RDRAM		0x0200		/* Bit  9: RDRAM reg mode */

/* MI version (R): [7:0] io, [15:8] rac, [23:16] rdp, [31:24] rsp */
#define MI_VERSION_REG		(MI_BASE_REG+0x04)
#define MI_NOOP_REG		MI_VERSION_REG

/* MI interrupt (R): [5:0] valid bits - see below for bit patterns */
#define MI_INTR_REG		(MI_BASE_REG+0x08)

/* 
 * MI interrupt mask (W): [11:0] valid bits - see below for bit patterns 
 *                   (R): [5:0] valid bits - see below for bit patterns 
 */
#define MI_INTR_MASK_REG	(MI_BASE_REG+0x0C)

/*
 * The following are values to check for interrupt setting (MI_INTR_REG)
 */
#define MI_INTR_SP		0x01		/* Bit 0: SP intr */
#define MI_INTR_SI		0x02		/* Bit 1: SI intr */
#define MI_INTR_AI		0x04		/* Bit 2: AI intr */
#define MI_INTR_VI		0x08		/* Bit 3: VI intr */
#define MI_INTR_PI		0x10		/* Bit 4: PI intr */
#define MI_INTR_DP		0x20		/* Bit 5: DP intr */

/*
 * The following are values to clear/set various interrupt bit mask
 * They can be ORed together to manipulate multiple bits 
 * (MI_INTR_MASK_REG - write)
 */
#define MI_INTR_MASK_CLR_SP	0x0001		/* Bit  0: clear SP mask */
#define MI_INTR_MASK_SET_SP	0x0002		/* Bit  1: set SP mask */
#define MI_INTR_MASK_CLR_SI	0x0004		/* Bit  2: clear SI mask */
#define MI_INTR_MASK_SET_SI	0x0008		/* Bit  3: set SI mask */
#define MI_INTR_MASK_CLR_AI	0x0010		/* Bit  4: clear AI mask */
#define MI_INTR_MASK_SET_AI	0x0020		/* Bit  5: set AI mask */
#define MI_INTR_MASK_CLR_VI	0x0040		/* Bit  6: clear VI mask */
#define MI_INTR_MASK_SET_VI	0x0080		/* Bit  7: set VI mask */
#define MI_INTR_MASK_CLR_PI	0x0100		/* Bit  8: clear PI mask */
#define MI_INTR_MASK_SET_PI	0x0200		/* Bit  9: set PI mask */
#define MI_INTR_MASK_CLR_DP	0x0400		/* Bit 10: clear DP mask */
#define MI_INTR_MASK_SET_DP	0x0800		/* Bit 11: set DP mask */

/*
 * The following are values to check for interrupt mask setting 
 * (MI_INTR_MASK_REG - read)
 */
#define MI_INTR_MASK_SP		0x01		/* Bit 0: SP intr mask */
#define MI_INTR_MASK_SI		0x02		/* Bit 1: SI intr mask */
#define MI_INTR_MASK_AI		0x04		/* Bit 2: AI intr mask */
#define MI_INTR_MASK_VI		0x08		/* Bit 3: VI intr mask */
#define MI_INTR_MASK_PI		0x10		/* Bit 4: PI intr mask */
#define MI_INTR_MASK_DP		0x20		/* Bit 5: DP intr mask */


/*************************************************************************
 * Video Interface (VI) Registers 
 */
#define VI_BASE_REG		0x04400000

/* VI status (R/W): TBD */
#define VI_STATUS_REG		(VI_BASE_REG+0x00)
#define VI_CONTROL_REG		VI_STATUS_REG

/* VI origin (R/W): [23:0] start RDRAM address */
#define VI_DRAM_ADDR_REG	(VI_BASE_REG+0x04)

/* VI width (R/W): [11:0] horizontal line width */
#define VI_H_WIDTH_REG	(VI_BASE_REG+0x08)	

/* VI vertical intr (R/W): [9:0] vertical line interrupt */
#define VI_V_INTR_REG		(VI_BASE_REG+0x0C)	

/* 
 * VI current vertical line (R/W): [9:0] current vertical line 
 * 	- Any write to this register will clear interrupt line
 */
#define VI_V_CURRENT_LINE_REG	(VI_BASE_REG+0x10)	

/* 
 * VI video timing (R/W): [ 7: 0] horizontal sync width, [15: 8] burst width
 *                        [19:16] vertical sync width,   [29:20] burst start
 */
#define VI_TIMING_REG		(VI_BASE_REG+0x14)	

/* VI vertical sync (R/W): [9:0] vertical sync */
#define VI_V_SYNC_REG		(VI_BASE_REG+0x18)	

/* VI horizontal sync (R/W): [9:0] horizontal sync */
#define VI_H_SYNC_REG		(VI_BASE_REG+0x1C)	

/* 
 * VI horizontal sync leap (R/W): [ 9: 0] horizontal sync leap B
 *                              : [25:16] horizontal sync leap A
 */
#define VI_H_SYNC_LEAP_REG	(VI_BASE_REG+0x20)	

/* 
 * VI horizontal video (R/W): [ 9: 0] horizontal video end
 *                          : [25:16] horizontal video start
 */
#define VI_H_VIDEO_REG		(VI_BASE_REG+0x24)	

/* 
 * VI vertical video (R/W): [ 9: 0] vertical video end
 *                        : [25:16] vertical video start
 */
#define VI_V_VIDEO_REG		(VI_BASE_REG+0x28)	

/* 
 * VI vertical burst (R/W): [ 9: 0] vertical burst end
 *                        : [25:16] vertical burst start
 */
#define VI_V_BURST_REG		(VI_BASE_REG+0x2C)	

/* VI x-scale (R/W): [11: 0] x scale */
#define VI_X_SCALE_REG		(VI_BASE_REG+0x30)	

/* VI y-scale (R/W): [11: 0] y scale */
#define VI_Y_SCALE_REG		(VI_BASE_REG+0x34)	

/* VI x-offset (R/W): [11: 0] x offset */
#define VI_X_OFFSET_REG		(VI_BASE_REG+0x38)	

/* VI y-offset (R/W): [11: 0] y offset */
#define VI_Y_OFFSET_REG		(VI_BASE_REG+0x3C)	


/*************************************************************************
 * Audio Interface (AI) Registers 
 *
 * AI controller has 5 writable regs and 2 readable regs: 
 *	Writable-only: R0, R2, R4, R5
 *	Readable-only: R3
 *	Write/Read:    R1
 *
 * The address and length registers are double buffered; that is, they
 * can be written twice before becoming full.
 * The address must be written before the length.
 */
#define AI_BASE_REG		0x04500000

/* AI DRAM address (W): [23:0] starting RDRAM address (8B-aligned) */
#define AI_DRAM_ADDR_REG	(AI_BASE_REG+0x00)	/* R0: DRAM address */

/* AI length (R/W): [20:0] transfer length - Bottom 3 bits are ignored */
#define AI_LEN_REG		(AI_BASE_REG+0x04)	/* R1: Length */

/* AI control (W): [20:0] DMA enable - if LSB == 1, DMA is enabled */
#define AI_CONTROL_REG		(AI_BASE_REG+0x08)	/* R2: DMA Control */

/* 
 * AI status (R): [31]/[0] ai_full (addr & len buffer full), [27] ai_busy 
 *                [21] current state of abus_word output pin
 *		  Note that a 1->0 transition in ai_full will set interrupt
 *           (W): clear audio interrupt 
 */
#define AI_STATUS_REG		(AI_BASE_REG+0x0C)	/* R3: Status */

/* 
 * AI DAC sample period register (W): [13:0] dac rate 
 *   - vid_clock/(dperiod + 1) is the DAC sample rate
 *   - (dperiod + 1) >= 66 * (aclockhp + 1) must be true
 */
#define AI_DACRATE_REG		(AI_BASE_REG+0x10)	/* R4: DAC rate 14-lsb*/

/* 
 * AI bit rate (W): [3:0] bit rate (abus clock half period register - aclockhp)
 *   - vid_clock/(2 * (aclockhp + 1)) is the DAC clock rate
 *   - The abus clock stops if aclockhp is zero
 */
#define AI_BITRATE_REG		(AI_BASE_REG+0x14)	/* R5: Bit rate 4-lsb */

/* Value for control register */
#define AI_CONTROL_DMA_ON	0x01			/* LSB = 1: DMA enable*/
#define AI_CONTROL_DMA_OFF	0x00			/* LSB = 1: DMA enable*/

/* Value for status register */
#define AI_STATUS_FIFO_FULL	0x80000000		/* Bit 31: full */
#define AI_STATUS_DMA_BUSY	0x40000000		/* Bit 30: busy */


/*************************************************************************
 * Peripheral Interface (PI) Registers 
 */
#define PI_BASE_REG		0x04600000

/* PI DRAM address (R/W): [23:0] starting RDRAM address */
#define PI_DRAM_ADDR_REG	(PI_BASE_REG+0x00)	/* DRAM address */

/* PI pbus (cartridge) address (R/W): [31:0] starting AD16 address */
#define PI_CART_ADDR_REG	(PI_BASE_REG+0x04)

/* PI read length (R/W): [15:0] read data length */
#define PI_RD_LEN_REG		(PI_BASE_REG+0x08)

/* PI write length (R/W): [15:0] write data length */
#define PI_WR_LEN_REG		(PI_BASE_REG+0x0C)

/* 
 * PI status (R): [0] DMA busy, [1] IO busy, [2], error
 *           (W): [0] reset controller (and abort current op), [1] clear intr
 */
#define PI_STATUS_REG		(PI_BASE_REG+0x10)

/* PI dom1 latency (R/W): [7:0] domain 1 device latency */
#define PI_BSD_DOM1_LAT_REG	(PI_BASE_REG+0x14)

/* PI dom1 pulse width (R/W): [7:0] domain 1 device R/W strobe pulse width */
#define PI_BSD_DOM1_PWD_REG	(PI_BASE_REG+0x18)

/* PI dom1 page size (R/W): [3:0] domain 1 device page size */
#define PI_BSD_DOM1_PGS_REG	(PI_BASE_REG+0x1C)    /*   page size */

/* PI dom1 release (R/W): [1:0] domain 1 device R/W release duration */
#define PI_BSD_DOM1_RLS_REG	(PI_BASE_REG+0x20)

/* PI dom2 latency (R/W): [7:0] domain 2 device latency */
#define PI_BSD_DOM2_LAT_REG	(PI_BASE_REG+0x24)    /* Domain 2 latency */

/* PI dom2 pulse width (R/W): [7:0] domain 2 device R/W strobe pulse width */
#define PI_BSD_DOM2_PWD_REG	(PI_BASE_REG+0x28)    /*   pulse width */

/* PI dom2 page size (R/W): [3:0] domain 2 device page size */
#define PI_BSD_DOM2_PGS_REG	(PI_BASE_REG+0x2C)    /*   page size */

/* PI dom2 release (R/W): [1:0] domain 2 device R/W release duration */
#define PI_BSD_DOM2_RLS_REG	(PI_BASE_REG+0x30)    /*   release duration */

#define PI_IO_READ_REG		(PI_BASE_REG+0x34)	
#define PI_IO_WRITE_REG		(PI_BASE_REG+0x38)	

#define	PI_DOMAIN1_REG		PI_BSD_DOM1_LAT_REG
#define	PI_DOMAIN2_REG		PI_BSD_DOM2_LAT_REG

#define PI_DOM_LAT_OFS		0x00
#define PI_DOM_PWD_OFS		0x04
#define PI_DOM_PGS_OFS		0x08
#define PI_DOM_RLS_OFS		0x0C

/*
 * PI status register has 3 bits active when read from (PI_STATUS_REG - read)
 *	Bit 0: DMA busy - set when DMA is in progress
 *	Bit 1: IO busy  - set when IO is in progress
 *	Bit 2: Error    - set when CPU issues IO request while DMA is busy
 */
#define	PI_STATUS_ERROR		0x04
#define	PI_STATUS_IO_BUSY	0x02
#define	PI_STATUS_DMA_BUSY	0x01

/* PI status register has 2 bits active when written to:
 *	Bit 0: When set, reset PIC
 *	Bit 1: When set, clear interrupt flag
 * The values of the two bits can be ORed together to both reset PIC and 
 * clear interrupt at the same time.
 *
 * Note: 
 *	- The PIC does generate an interrupt at the end of each DMA. CPU 
 *	needs to clear the interrupt flag explicitly (from an interrupt 
 *	handler) by writing into the STATUS register with bit 1 set.
 *
 *	- When a DMA completes, the interrupt flag is set.  CPU can issue
 *	another request even while the interrupt flag is set (as long as
 *	PIC is idle).  However, it is the CPU's responsibility for
 *	maintaining accurate correspondence between DMA completions and
 *	interrupts.
 *
 *	- When PIC is reset, if PIC happens to be busy, an interrupt will
 *	be generated as PIC returns to idle.  Otherwise, no interrupt will
 *	be generated and PIC remains idle.
 */
/*
 * Values to clear interrupt/reset PIC (PI_STATUS_REG - write)
 */
#define	PI_STATUS_RESET		0x01
#define	PI_SET_RESET		PI_STATUS_RESET

#define	PI_STATUS_CLR_INTR	0x02
#define	PI_CLR_INTR		PI_STATUS_CLR_INTR

#define	PI_DMA_BUFFER_SIZE	128

/* reset */
#ifdef __sgi__
    #define PI_RESET()	{ *(vu_int *)PHYS_TO_K1(PI_STATUS_REG)=PI_SET_RESET; }
#else
    void   linux_io_write(unsigned long addr, unsigned int data);
    #define PI_RESET() linux_io_write((PI_STATUS_REG), PI_SET_RESET)
#endif

#define PI_DOM1_ADDR1		0x06000000
#define PI_DOM1_ADDR2		0x10000000
#define PI_DOM2_ADDR1		0x05000000
#define PI_DOM2_ADDR2		0x08000000


/*************************************************************************
 * RDRAM Interface (RI) Registers 
 */
#define RI_BASE_REG		0x04700000

/* RI mode (R/W): [1:0] operating mode, [2] stop T active, [3] stop R active */
#define RI_MODE_REG		(RI_BASE_REG+0x00)	

/* RI config (R/W): [5:0] current control input, [6] current control enable */
#define RI_CONFIG_REG		(RI_BASE_REG+0x04)

/* RI current load (W): [] any write updates current control register */
#define RI_CURRENT_LOAD_REG	(RI_BASE_REG+0x08)

/* RI select (R/W): [2:0] receive select, [2:0] transmit select */
#define RI_SELECT_REG		(RI_BASE_REG+0x0C)

/* RI refresh (R/W): [7:0] clean refresh delay, [15:8] dirty refresh delay,
 *		     [16] refresh bank, [17] refresh enable 
 *		     [18] refresh optimize 
 */
#define RI_REFRESH_REG		(RI_BASE_REG+0x10)
#define RI_COUNT_REG		RI_REFRESH_REG

/* RI latency (R/W): [3:0] DMA latency/overlap */
#define RI_LATENCY_REG		(RI_BASE_REG+0x14)

/* RI error (R): [0] nack error, [1] ack error */
#define RI_RERROR_REG		(RI_BASE_REG+0x18)

/* RI error (W): [] any write clears all error bits */
#define RI_WERROR_REG		(RI_BASE_REG+0x1C)


/*************************************************************************
 * Serial Interface (SI) Registers 
 *
 * SI supports 3 basic functions:
 *	1) IO reads:	32-bit access of CPU requested read operation
 *	2) DMA write:	4-byte or 64-byte transfers from PIF RAM to DRAM
 *	3) DMA read:	4-byte or 64-byte transfers from DRAM to PIF RAM
 */
#define SI_BASE_REG		0x04800000

/* SI DRAM address (R/W): [23:0] starting RDRAM address */
#define SI_DRAM_ADDR_REG	(SI_BASE_REG+0x00)	/* R0: DRAM address */

/* SI address read 64B (W): [] any write causes a 64B DMA write */
#define SI_PIF_ADDR_RD64B_REG	(SI_BASE_REG+0x04)	/* R1: 64B PIF->DRAM */

/* Address SI_BASE_REG + (0x08, 0x0c, 0x14) are reserved */

/* SI address write 64B (W): [] any write causes a 64B DMA read */
#define SI_PIF_ADDR_WR64B_REG	(SI_BASE_REG+0x10)	/* R4: 64B DRAM->PIF */

/* 
 * SI status (W): [] any write clears interrupt
 *           (R): [0] DMA busy, [1] IO read busy, [2] reserved
 *                [3] DMA error, [12] interrupt
 */
#define SI_STATUS_REG		(SI_BASE_REG+0x18)	/* R6: Status */

/* SI status register has the following bits active:
 *	0:   DMA busy		- set when DMA is in progress
 *	1:   IO read busy	- set when IO read is in progress
 *	2:   Reserved
 *	3:   DMA error		- set when there are overlapping DMA requests
 *    [7-4]: PCH state		- Use for debugging
 *   [11-8]: DMA state		- Use for debugging
 *     12:   Interrupt		- Interrupt set
 */
#define	SI_STATUS_DMA_BUSY	0x0001
#define	SI_STATUS_RD_BUSY	0x0002
#define	SI_STATUS_DMA_ERROR	0x0008
#define	SI_STATUS_INTERRUPT	0x1000

/* Define types for SI DMA operation */
/* Values 1/2 were used for cancelled 4B operations */
#define SI_RD64B		3
#define SI_WR64B		4


/*************************************************************************
 * Common definitions
 */
#define	DIR_FROM_RAM		1	/* Direction of data: -> DRAM */
#define DIR_TO_RAM		2	/* Direction of data: <- DRAM */


/*************************************************************************
 * Common macros
 */
#ifdef _LANGUAGE_C
#ifdef __sgi__
    #define IO_READ(addr)		(*(vu_int *)PHYS_TO_K1(addr))
    #define IO_WRITE(addr,data)	(*(vu_int *)PHYS_TO_K1(addr)=(unsigned)(data))
#else
    unsigned int linux_io_read(unsigned long addr);
    void   linux_io_write(unsigned long addr, unsigned int data);
    #define IO_READ(addr)         linux_io_read(addr)
    #define IO_WRITE(addr, data)  linux_io_write((addr), data)
#endif
#endif

#endif  /* _IO_MAP_H_ */