commonchip.cfg

flash programming STI 5.5.1.4 DCU3

  register 1284IntStatus   (addr+0x50) -group IEEE1284ParallelPort -readonly
  register 1284IntAck      (addr+0x54) -group IEEE1284ParallelPort -writeonly
}

proc IEEE1394LLIRegisters addr=$1 sync=$2 {
  if (clsymbol ST_reg_debug) { write "IEEE1394LLIRegisters @ " -x (addr) " sync=" (sync) } 
  register LLIControl        (addr)      -group IEEE1394LLI
  register LLIByteClockRatio (addr+0x4)  -group IEEE1394LLI
  if (sync==true) {
    register LLISyncLock     (addr+0x14) -group IEEE1394LLI -writeonly
    register LLISyncDrop     (addr+0x16) -group IEEE1394LLI -writeonly
    register LLISyncPeriod   (addr+0x18) -group IEEE1394LLI -writeonly
  }
}

proc InterruptControllerWptrTrigRegisters addr=$1 numint=$2 c2core=$3 wptroffset=$4 triggeroffset=$5 i=0 {
  if (clsymbol ST_reg_debug) { write "InterruptControllerWptrTrigRegisters @ " -x (addr) (numint) (c2core) -x (wptroffset) -x (triggeroffset) } 

  for (i=0;i<numint;i++) {
    if ( c2core == true ) {
      register ("HandlerWptr"+(mkstr(i))) (addr+wptroffset+(4*i)) -group InterruptController
    }
    register ("TriggerMode"+(mkstr(i))) (addr+triggeroffset+(4*i)) -group InterruptController
  }
}

## Supply base address and number of interrupt levels
##
proc InterruptControllerNLevelsRegisters addr=$1 numint=$2 {
  if (clsymbol ST_reg_debug) { write "InterruptControllerNLevelsRegisters @ " -x (addr) (numint) } 

  InterruptControllerWptrTrigRegisters (addr) (numint) (true) (0x0) (0x40)

  register Pending       (addr+0x80)  -group InterruptController
  register Set_Pending   (addr+0x84)  -group InterruptController -writeonly
  register Clear_Pending (addr+0x88)  -group InterruptController -writeonly
  register Mask          (addr+0xc0)  -group InterruptController
  register Set_Mask      (addr+0xc4)  -group InterruptController -writeonly
  register Clear_Mask    (addr+0xc8)  -group InterruptController -writeonly
  register Exec          (addr+0x100) -group InterruptController
  register Set_Exec      (addr+0x104) -group InterruptController -writeonly
  register Clear_Exec    (addr+0x108) -group InterruptController -writeonly
}

proc InterruptControllerRegisters addr=$1 {
  if (clsymbol ST_reg_debug) { write "InterruptControllerRegisters @ " -x (addr) } 
  InterruptControllerNLevelsRegisters (addr) (8)
}

proc InterruptController2Registers addr=$1 numint=$2 c2core=$3 i=0 {
  if (clsymbol ST_reg_debug) { write "InterruptController2Registers @ " -x (addr) } 

  register RevID         (addr+0x000) -group InterruptController -readonly
  register Numints       (addr+0x004) -group InterruptController -readonly
  register Pending       (addr+0x010) -group InterruptController
  register Set_Pending   (addr+0x014) -group InterruptController -writeonly
  register Clear_Pending (addr+0x018) -group InterruptController -writeonly
  register Mask          (addr+0x020) -group InterruptController
  register Set_Mask      (addr+0x024) -group InterruptController -writeonly
  register Clear_Mask    (addr+0x028) -group InterruptController -writeonly
  register Global_Mask   (addr+0x030) -group InterruptController
  register Exec          (addr+0x040) -group InterruptController
  register Set_Exec      (addr+0x044) -group InterruptController -writeonly
  register Clear_Exec    (addr+0x048) -group InterruptController -writeonly

  InterruptControllerWptrTrigRegisters (addr) (numint) (c2core) (0x100) (0x180)
}

proc InterruptLevelControllerRegisters addr=$1 numinterrupts=$2 ext=$3 gps=$4 i=0 {
  if (clsymbol ST_reg_debug) { write "InterruptLevelControllerRegisters @ " -x (addr) " numinterrupts=" (numinterrupts) \
     " ext=" (ext) " gps=" (gps) } 
  for (i=0;i<numinterrupts;i++) {
    register ("Int"+(mkstr(i))+"Priority") (addr+(i*4)) -group InterruptLevelController
  }
  if (ext == true) {
    register SelectnotInv  (addr+0x60) -group InterruptLevelController
    register ExtIntEnable  (addr+0x64) -group InterruptLevelController
  }
  register InputInterrupts (addr+0x7c) -group InterruptLevelController -readonly
  if (gps == true) {
    register IntActiveHigh (addr+0x4c) -group InterruptLevelController
    register IntLPEnable   (addr+0x50) -group InterruptLevelController
  }
}

proc InterruptLevelController2Registers addr=$1 numinterrupts=$2 i=0 {
  if (clsymbol ST_reg_debug) { write "InterruptLevelController2Registers @ " -x (addr) " numinterrupts=" (numinterrupts) }

  register InputInterrupts (addr+0x07c) -group InterruptLevelController -readonly
  register ClearEnable     (addr+0x1b4) -group InterruptLevelController -writeonly
  register SetEnable       (addr+0x1b8) -group InterruptLevelController -writeonly
  register Enable          (addr+0x1bc) -group InterruptLevelController
  register SelectnotInv    (addr+0x1c8) -group InterruptLevelController
  register ExtIntEnable    (addr+0x1cc) -group InterruptLevelController
  register Status_ilc2     (addr+0x1dc) -group InterruptLevelController -readonly
  register ClearEdgeInt    (addr+0x1ec) -group InterruptLevelController -writeonly

  for (i=0;i<numinterrupts;i++) {
    register ("Int"+(mkstr(i))+"Priority") (addr+(i*4)) -group InterruptLevelController
    register ("Int"+(mkstr(i))+"Mode") (addr+(i*4)+0xbc) -group InterruptLevelController
  }
}

proc InterruptLevelController3Registers addr=$1 numinterrupts=$2 i=0 {
  if (clsymbol ST_reg_debug) { write "InterruptLevelController3Registers @ " -x (addr) " numinterrupts=" (numinterrupts) }

  register InputInterrupts0	(addr+0x080)	-group InterruptLevelController -readonly
  register InputInterrupts1	(addr+0x084)	-group InterruptLevelController -readonly
  register InputInterrupts2	(addr+0x088)	-group InterruptLevelController -readonly
  register InputInterrupts3	(addr+0x08c)	-group InterruptLevelController -readonly

  register Status0		(addr+0x200)	-group InterruptLevelController -readonly
  register Status1		(addr+0x204)	-group InterruptLevelController -readonly
  register Status2		(addr+0x208)	-group InterruptLevelController -readonly
  register Status3		(addr+0x20c)	-group InterruptLevelController -readonly

  register ClearStatus0		(addr+0x280)	-group InterruptLevelController -writeonly
  register ClearStatus1		(addr+0x284)	-group InterruptLevelController -writeonly
  register ClearStatus2		(addr+0x288)	-group InterruptLevelController -writeonly
  register ClearStatus3		(addr+0x28c)	-group InterruptLevelController -writeonly

  register Enable0		(addr+0x400)	-group InterruptLevelController
  register Enable1		(addr+0x404)	-group InterruptLevelController
  register Enable2		(addr+0x408)	-group InterruptLevelController
  register Enable3		(addr+0x40c)	-group InterruptLevelController

  register ClearEnable0		(addr+0x480)	-group InterruptLevelController -writeonly
  register ClearEnable1		(addr+0x484)	-group InterruptLevelController -writeonly
  register ClearEnable2		(addr+0x488)	-group InterruptLevelController -writeonly
  register ClearEnable3		(addr+0x48c)	-group InterruptLevelController -writeonly

  register SetEnable0		(addr+0x500)	-group InterruptLevelController -writeonly
  register SetEnable1		(addr+0x504)	-group InterruptLevelController -writeonly
  register SetEnable2		(addr+0x508)	-group InterruptLevelController -writeonly
  register SetEnable3		(addr+0x50c)	-group InterruptLevelController -writeonly

  register WakeupEnable0	(addr+0x600)	-group InterruptLevelController
  register WakeupEnable1	(addr+0x604)	-group InterruptLevelController
  register WakeupEnable2	(addr+0x608)	-group InterruptLevelController
  register WakeupEnable3	(addr+0x60c)	-group InterruptLevelController

  register WakeupActiveLevel0	(addr+0x680)	-group InterruptLevelController
  register WakeupActiveLevel1	(addr+0x684)	-group InterruptLevelController
  register WakeupActiveLevel2	(addr+0x688)	-group InterruptLevelController
  register WakeupActiveLevel3	(addr+0x68c)	-group InterruptLevelController

  for (i=0;i<numinterrupts;i++) {
    register ("Int"+(mkstr(i))+"Priority") (addr+(i*8)+0x800) -group InterruptLevelController
    register ("Int"+(mkstr(i))+"Mode") (addr+(i*8)+0x804) -group InterruptLevelController
  }
}

proc LowPowerControllerRegisters addr=$1 wd=$2 {
  if (clsymbol ST_reg_debug) { write "LowPowerControllerRegisters @ " -x (addr) " wd=" (wd) } 
  register LPTimerLS    (addr)       -group LowPowerController
  register LPTimerMS    (addr+0x4)   -group LowPowerController
  register LPTimerStart (addr+0x8)   -group LowPowerController -writeonly
  register LPAlarmLS    (addr+0x10)  -group LowPowerController
  register LPAlarmMS    (addr+0x14)  -group LowPowerController
  register LPAlarmStart (addr+0x18)  -group LowPowerController -writeonly
  register LPSysPll     (addr+0x20)  -group LowPowerController
  register SysRatio     (addr+0x100) -group LowPowerController -readonly
  if (wd == true) {
    register WdEnable     (addr+0x110) -group LowPowerController
    register WdFlag       (addr+0x114) -group LowPowerController -readonly
  }
}

proc MPEGDMAControllerRegisters addr=$1 num=$2 {
  if (clsymbol ST_reg_debug) { write "MPEGDMAControllerRegisters @ " -x (addr) } 
  register ("MPEG"+(mkstr(num))+"BurstSize")     (addr)      -group ("MPEGDMA"+(mkstr(num))) -writeonly
  register ("MPEG"+(mkstr(num))+"Holdoff")       (addr+0x04) -group ("MPEGDMA"+(mkstr(num))) -writeonly
  register ("MPEG"+(mkstr(num))+"Suspend")       (addr+0x08) -group ("MPEGDMA"+(mkstr(num))) -writeonly
  register ("MPEG"+(mkstr(num))+"DecoderSelect") (addr+0x0c) -group ("MPEGDMA"+(mkstr(num))) -writeonly
}

proc MPEGDMAController2Registers addr=$1 num=$2 {
  ## 5508
  if (clsymbol ST_reg_debug) { write "MPEGDMAController2Registers @ " -x (addr) } 
  register ("MPEGDMA" + (mkstr(num)) + "_BURSTSIZE") (addr + 0x00) -group ("MPEGDMA"+(mkstr(num))) -char -writeonly
  register ("MPEGDMA" + (mkstr(num)) + "_HOLDOFF")   (addr + 0x04) -group ("MPEGDMA"+(mkstr(num))) -char -writeonly
  register ("MPEGDMA" + (mkstr(num)) + "_ABORT") 	   (addr + 0x08) -group ("MPEGDMA"+(mkstr(num))) -char -writeonly
  register ("MPEGDMA" + (mkstr(num)) + "_WHICHDEC")  (addr + 0x0C) -group ("MPEGDMA"+(mkstr(num))) -char -writeonly
  register ("MPEGDMA" + (mkstr(num)) + "_STATUS")    (addr + 0x10) -group ("MPEGDMA"+(mkstr(num))) -char -readonly
  register ("MPEGDMA" + (mkstr(num)) + "_INTACK")    (addr + 0x14) -group ("MPEGDMA"+(mkstr(num))) -char -writeonly
  register ("MPEGDMA" + (mkstr(num)) + "_SRCADD")    (addr + 0x18) -group ("MPEGDMA"+(mkstr(num))) -writeonly
  register ("MPEGDMA" + (mkstr(num)) + "_CNTRL") 	   (addr + 0x1C) -group ("MPEGDMA"+(mkstr(num))) -char 
  register ("MPEGDMA" + (mkstr(num)) + "_BLSIZE")    (addr + 0x20) -group ("MPEGDMA"+(mkstr(num))) -short -writeonly
}

proc PeripheralPowerControllerRegisters addr=$1 chiptype=$2 {
  if (clsymbol ST_reg_debug) { write "PeripheralPowerControllerRegisters @ " -x (addr) } 
  register PowerControl0       (addr+0x000) -group PeripheralPowerController
  register PowerControl0_Set   (addr+0x004) -group PeripheralPowerController -writeonly
  register PowerControl0_Clear (addr+0x008) -group PeripheralPowerController -writeonly
  register PowerControl1       (addr+0x00c) -group PeripheralPowerController
  register PowerControl1_Set   (addr+0x010) -group PeripheralPowerController -writeonly
  register PowerControl1_Clear (addr+0x014) -group PeripheralPowerController -writeonly
  register Busy                (addr+0x018) -group PeripheralPowerController -readonly
  register PowerStatus         (addr+0x01c) -group PeripheralPowerController -readonly
  register PLLConfig           (addr+0x020) -group PeripheralPowerController 
  register PLLEnable           (addr+0x024) -group PeripheralPowerController
  register PLLLocked           (addr+0x028) -group PeripheralPowerController -readonly
  register Strobe              (addr+0x02c) -group PeripheralPowerController
  register OscillatorEnable    (addr+0x030) -group PeripheralPowerController
}

proc PESParserRegisters addr=$1 {
  if (clsymbol ST_reg_debug) { write "PESParserRegisters @ " -x (addr) } 
  register PES_CF1 (addr+0x40) -group PESParser -char
  register PES_CF2 (addr+0x41) -group PESParser -char
  register PES_TM1 (addr+0x42) -group PESParser -char -readonly
  register PES_TM2 (addr+0x43) -group PESParser -char -readonly
  register PES_TS1 (addr+0x49) -group PESParser       -readonly -p Unaligned4Register
  register PES_TS2 (addr+0x4d) -group PESParser -char -readonly
}

proc PIOGp reg=$1 addr=$2 num=$3 {
  if (clsymbol ST_reg_debug) { write "PIOGp @ " -x (addr) " num=" (num) } 
  register ("P"      +(mkstr(num))+(reg)) (addr)     -group ("PIOPort"+(mkstr(num)))
  register ("Set_P"  +(mkstr(num))+(reg)) (addr+0x4) -group ("PIOPort"+(mkstr(num))) -writeonly
  register ("Clear_P"+(mkstr(num))+(reg)) (addr+0x8) -group ("PIOPort"+(mkstr(num))) -writeonly
}

proc PIOControllerRegisters addr=$1 num=$2 {
  if (clsymbol ST_reg_debug) { write "PIOControllerRegisters @ " -x (addr) " num=" (num) } 
  PIOGp("Out",  addr,      num)
  register ("P"+(mkstr(num))+"In") (addr+0x10) -group ("PIOPort"+mkstr(num)) -readonly
  PIOGp("C0",   addr+0x20, num)
  PIOGp("C1",   addr+0x30, num)
  PIOGp("C2",   addr+0x40, num)
  PIOGp("Comp", addr+0x50, num)
  PIOGp("Mask", addr+0x60, num)
}

proc PTIRegisters addr=$1 i=0 {
  if (clsymbol ST_reg_debug) { write "PTIRegisters @ " -x (addr) } 
  for (i=0;i<4;i++) {
    register ("PTIIntStatus"+(mkstr(i))) (addr+(i*4))      -group PTI -readonly
    register ("PTIIntEnable"+(mkstr(i))) (addr+0x10+(i*4)) -group PTI
    register ("PTIIntAck"   +(mkstr(i))) (addr+0x20+(i*4)) -group PTI -writeonly
  }
  register TCMode                       (addr+0x30)      -group PTI
  for (i=0;i<2;i++) {
    register ("STCTimer"    +(mkstr(i))) (addr+0x50+(i*4)) -group PTI -writeonly
  }
}

proc PTIDMARegisters addr=$1 i=0 {
  if (clsymbol ST_reg_debug) { write "PTIDMARegisters @ " -x (addr) } 
  for (i=0;i<4;i++) {
    register ("DMA"+(mkstr(i))+"Base")    (addr+(i*4))      -group PTIDMA -writeonly
    register ("DMA"+(mkstr(i))+"Top")     (addr+0x10+(i*4)) -group PTIDMA -writeonly
  }