From 00daa7c67a1be3a0007f5ad135aa44d4ab71542c Mon Sep 17 00:00:00 2001 From: Maurus Cuelenaere Date: Sat, 21 Jun 2008 17:18:24 +0000 Subject: [PATCH] Add basic Jz4740 USB tool for messing with Ingenic chipset players git-svn-id: svn://svn.rockbox.org/rockbox/trunk@17746 a1c6a512-1295-4272-9138-f99709370657 --- utils/jz4740_usbtool/Makefile | 9 + utils/jz4740_usbtool/jz4740.h | 2358 +++++++++++++++++ utils/jz4740_usbtool/jz4740_usbtool.c | 477 ++++ .../windows_driver/jz4740_usbtool.cat | 3 + .../windows_driver/jz4740_usbtool.inf | 136 + .../windows_driver/jz4740_usbtool_x64.cat | 3 + .../jz4740_usbtool/windows_driver/libusb0.dll | Bin 0 -> 43520 bytes .../jz4740_usbtool/windows_driver/libusb0.sys | Bin 0 -> 28672 bytes .../windows_driver/libusb0_x64.dll | Bin 0 -> 43008 bytes .../windows_driver/libusb0_x64.sys | Bin 0 -> 16896 bytes 10 files changed, 2986 insertions(+) create mode 100755 utils/jz4740_usbtool/Makefile create mode 100755 utils/jz4740_usbtool/jz4740.h create mode 100755 utils/jz4740_usbtool/jz4740_usbtool.c create mode 100755 utils/jz4740_usbtool/windows_driver/jz4740_usbtool.cat create mode 100755 utils/jz4740_usbtool/windows_driver/jz4740_usbtool.inf create mode 100755 utils/jz4740_usbtool/windows_driver/jz4740_usbtool_x64.cat create mode 100755 utils/jz4740_usbtool/windows_driver/libusb0.dll create mode 100755 utils/jz4740_usbtool/windows_driver/libusb0.sys create mode 100755 utils/jz4740_usbtool/windows_driver/libusb0_x64.dll create mode 100755 utils/jz4740_usbtool/windows_driver/libusb0_x64.sys diff --git a/utils/jz4740_usbtool/Makefile b/utils/jz4740_usbtool/Makefile new file mode 100755 index 0000000000..e61b837d99 --- /dev/null +++ b/utils/jz4740_usbtool/Makefile @@ -0,0 +1,9 @@ +WIN_DRIVERS_LIBUSB_DIR = D:\Program Files\LibUSB-Win32 +WIN_LIBUSB_INCLUDE_DIR = "$(WIN_DRIVERS_LIBUSB_DIR)\include" +WIN_LIBUSB_LIB_DIR = "$(WIN_DRIVERS_LIBUSB_DIR)\lib\gcc" + +usbtool: + gcc -Wall -o usbtool jz4740_usbtool.c -lusb + +usbtoolwin: + gcc -Wall -o usbtool.exe jz4740_usbtool.c -lusb -I $(WIN_LIBUSB_INCLUDE_DIR) -L $(WIN_LIBUSB_LIB_DIR) \ No newline at end of file diff --git a/utils/jz4740_usbtool/jz4740.h b/utils/jz4740_usbtool/jz4740.h new file mode 100755 index 0000000000..87b400e3b9 --- /dev/null +++ b/utils/jz4740_usbtool/jz4740.h @@ -0,0 +1,2358 @@ +/* + * Include file for Ingenic Semiconductor's JZ4740 CPU. + */ +#ifndef __JZ4740_H__ +#define __JZ4740_H__ + +#define REG8(addr) (addr) +#define REG16(addr) (addr) +#define REG32(addr) (addr) + +//---------------------------------------------------------------------- +// Boot ROM Specification +// + +/* NOR Boot config */ +#define JZ4740_NORBOOT_8BIT 0x00000000 /* 8-bit data bus flash */ +#define JZ4740_NORBOOT_16BIT 0x10101010 /* 16-bit data bus flash */ +#define JZ4740_NORBOOT_32BIT 0x20202020 /* 32-bit data bus flash */ + +/* NAND Boot config */ +#define JZ4740_NANDBOOT_B8R3 0xffffffff /* 8-bit bus & 3 row cycles */ +#define JZ4740_NANDBOOT_B8R2 0xf0f0f0f0 /* 8-bit bus & 2 row cycles */ +#define JZ4740_NANDBOOT_B16R3 0x0f0f0f0f /* 16-bit bus & 3 row cycles */ +#define JZ4740_NANDBOOT_B16R2 0x00000000 /* 16-bit bus & 2 row cycles */ + + +//---------------------------------------------------------------------- +// Register Definitions +// +#define CPM_BASE 0xB0000000 +#define INTC_BASE 0xB0001000 +#define TCU_BASE 0xB0002000 +#define WDT_BASE 0xB0002000 +#define RTC_BASE 0xB0003000 +#define GPIO_BASE 0xB0010000 +#define AIC_BASE 0xB0020000 +#define ICDC_BASE 0xB0020000 +#define MSC_BASE 0xB0021000 +#define UART0_BASE 0xB0030000 +#define I2C_BASE 0xB0042000 +#define SSI_BASE 0xB0043000 +#define SADC_BASE 0xB0070000 +#define EMC_BASE 0xB3010000 +#define DMAC_BASE 0xB3020000 +#define UHC_BASE 0xB3030000 +#define UDC_BASE 0xB3040000 +#define LCD_BASE 0xB3050000 +#define SLCD_BASE 0xB3050000 +#define CIM_BASE 0xB3060000 +#define ETH_BASE 0xB3100000 + + +/************************************************************************* + * INTC (Interrupt Controller) + *************************************************************************/ +#define INTC_ISR (INTC_BASE + 0x00) +#define INTC_IMR (INTC_BASE + 0x04) +#define INTC_IMSR (INTC_BASE + 0x08) +#define INTC_IMCR (INTC_BASE + 0x0c) +#define INTC_IPR (INTC_BASE + 0x10) + +#define REG_INTC_ISR REG32(INTC_ISR) +#define REG_INTC_IMR REG32(INTC_IMR) +#define REG_INTC_IMSR REG32(INTC_IMSR) +#define REG_INTC_IMCR REG32(INTC_IMCR) +#define REG_INTC_IPR REG32(INTC_IPR) + +// 1st-level interrupts +#define IRQ_I2C 1 +#define IRQ_UHC 3 +#define IRQ_UART0 9 +#define IRQ_SADC 12 +#define IRQ_MSC 14 +#define IRQ_RTC 15 +#define IRQ_SSI 16 +#define IRQ_CIM 17 +#define IRQ_AIC 18 +#define IRQ_ETH 19 +#define IRQ_DMAC 20 +#define IRQ_TCU2 21 +#define IRQ_TCU1 22 +#define IRQ_TCU0 23 +#define IRQ_UDC 24 +#define IRQ_GPIO3 25 +#define IRQ_GPIO2 26 +#define IRQ_GPIO1 27 +#define IRQ_GPIO0 28 +#define IRQ_IPU 29 +#define IRQ_LCD 30 + +// 2nd-level interrupts +#define IRQ_DMA_0 32 /* 32 to 37 for DMAC channel 0 to 5 */ +#define IRQ_GPIO_0 48 /* 48 to 175 for GPIO pin 0 to 127 */ + + +/************************************************************************* + * RTC + *************************************************************************/ +#define RTC_RCR (RTC_BASE + 0x00) /* RTC Control Register */ +#define RTC_RSR (RTC_BASE + 0x04) /* RTC Second Register */ +#define RTC_RSAR (RTC_BASE + 0x08) /* RTC Second Alarm Register */ +#define RTC_RGR (RTC_BASE + 0x0c) /* RTC Regulator Register */ + +#define RTC_HCR (RTC_BASE + 0x20) /* Hibernate Control Register */ +#define RTC_HWFCR (RTC_BASE + 0x24) /* Hibernate Wakeup Filter Counter Reg */ +#define RTC_HRCR (RTC_BASE + 0x28) /* Hibernate Reset Counter Register */ +#define RTC_HWCR (RTC_BASE + 0x2c) /* Hibernate Wakeup Control Register */ +#define RTC_HWSR (RTC_BASE + 0x30) /* Hibernate Wakeup Status Register */ + +#define REG_RTC_RCR REG32(RTC_RCR) +#define REG_RTC_RSR REG32(RTC_RSR) +#define REG_RTC_RSAR REG32(RTC_RSAR) +#define REG_RTC_RGR REG32(RTC_RGR) +#define REG_RTC_HCR REG32(RTC_HCR) +#define REG_RTC_HWFCR REG32(RTC_HWFCR) +#define REG_RTC_HRCR REG32(RTC_HRCR) +#define REG_RTC_HWCR REG32(RTC_HWCR) +#define REG_RTC_HWSR REG32(RTC_HWSR) + +/* RTC Control Register */ +#define RTC_RCR_WRDY (1 << 7) /* Write Ready Flag */ +#define RTC_RCR_HZ (1 << 6) /* 1Hz Flag */ +#define RTC_RCR_HZIE (1 << 5) /* 1Hz Interrupt Enable */ +#define RTC_RCR_AF (1 << 4) /* Alarm Flag */ +#define RTC_RCR_AIE (1 << 3) /* Alarm Interrupt Enable */ +#define RTC_RCR_AE (1 << 2) /* Alarm Enable */ +#define RTC_RCR_RTCE (1 << 0) /* RTC Enable */ + +/* RTC Regulator Register */ +#define RTC_RGR_LOCK (1 << 31) /* Lock Bit */ +#define RTC_RGR_ADJC_BIT 16 +#define RTC_RGR_ADJC_MASK (0x3ff << RTC_RGR_ADJC_BIT) +#define RTC_RGR_NC1HZ_BIT 0 +#define RTC_REG_NC1HZ_MASK (0xffff << RTC_RGR_NC1HZ_BIT) + +/* Hibernate Control Register */ +#define RTC_HCR_PD (1 << 0) /* Power Down */ + +/* Hibernate Wakeup Filter Counter Register */ +#define RTC_HWFCR_BIT 5 +#define RTC_HWFCR_MASK (0x7ff << RTC_HWFCR_BIT) + +/* Hibernate Reset Counter Register */ +#define RTC_HRCR_BIT 5 +#define RTC_HRCR_MASK (0x7f << RTC_HRCR_BIT) + +/* Hibernate Wakeup Control Register */ +#define RTC_HWCR_WL (1 << 2) /* Wakeup pin level: 0-low 1-high */ +#define RTC_HWCR_EPIN (1 << 1) /* Wakeup pin wakeup enable */ +#define RTC_HWCR_EALM (1 << 0) /* RTC alarm wakeup enable */ + +/* Hibernate Wakeup Status Register */ +#define RTC_HWSR_HR (1 << 5) /* Hibernate reset */ +#define RTC_HWSR_POR (1 << 4) /* POR reset */ +#define RTC_HWSR_PIN (1 << 1) /* Wakeup pin status bit */ +#define RTC_HWSR_ALM (1 << 0) /* RTC alarm status bit */ + + +/************************************************************************* + * CPM (Clock reset and Power control Management) + *************************************************************************/ +#define CPM_CPCCR (CPM_BASE+0x00) +#define CPM_CPPCR (CPM_BASE+0x10) +#define CPM_I2SCDR (CPM_BASE+0x60) +#define CPM_LPCDR (CPM_BASE+0x64) +#define CPM_MSCCDR (CPM_BASE+0x68) +#define CPM_UHCCDR (CPM_BASE+0x6C) + +#define CPM_LCR (CPM_BASE+0x04) +#define CPM_CLKGR (CPM_BASE+0x20) +#define CPM_SCR (CPM_BASE+0x24) + +#define CPM_HCR (CPM_BASE+0x30) +#define CPM_HWFCR (CPM_BASE+0x34) +#define CPM_HRCR (CPM_BASE+0x38) +#define CPM_HWCR (CPM_BASE+0x3c) +#define CPM_HWSR (CPM_BASE+0x40) +#define CPM_HSPR (CPM_BASE+0x44) + +#define CPM_RSR (CPM_BASE+0x08) + + +#define REG_CPM_CPCCR REG32(CPM_CPCCR) +#define REG_CPM_CPPCR REG32(CPM_CPPCR) +#define REG_CPM_I2SCDR REG32(CPM_I2SCDR) +#define REG_CPM_LPCDR REG32(CPM_LPCDR) +#define REG_CPM_MSCCDR REG32(CPM_MSCCDR) +#define REG_CPM_UHCCDR REG32(CPM_UHCCDR) + +#define REG_CPM_LCR REG32(CPM_LCR) +#define REG_CPM_CLKGR REG32(CPM_CLKGR) +#define REG_CPM_SCR REG32(CPM_SCR) +#define REG_CPM_HCR REG32(CPM_HCR) +#define REG_CPM_HWFCR REG32(CPM_HWFCR) +#define REG_CPM_HRCR REG32(CPM_HRCR) +#define REG_CPM_HWCR REG32(CPM_HWCR) +#define REG_CPM_HWSR REG32(CPM_HWSR) +#define REG_CPM_HSPR REG32(CPM_HSPR) + +#define REG_CPM_RSR REG32(CPM_RSR) + + +/* Clock Control Register */ +#define CPM_CPCCR_I2CS (1 << 31) +#define CPM_CPCCR_CLKOEN (1 << 30) +#define CPM_CPCCR_UCS (1 << 29) +#define CPM_CPCCR_UDIV_BIT 23 +#define CPM_CPCCR_UDIV_MASK (0x3f << CPM_CPCCR_UDIV_BIT) +#define CPM_CPCCR_CE (1 << 22) +#define CPM_CPCCR_PCS (1 << 21) +#define CPM_CPCCR_LDIV_BIT 16 +#define CPM_CPCCR_LDIV_MASK (0x1f << CPM_CPCCR_LDIV_BIT) +#define CPM_CPCCR_MDIV_BIT 12 +#define CPM_CPCCR_MDIV_MASK (0x0f << CPM_CPCCR_MDIV_BIT) +#define CPM_CPCCR_PDIV_BIT 8 +#define CPM_CPCCR_PDIV_MASK (0x0f << CPM_CPCCR_PDIV_BIT) +#define CPM_CPCCR_HDIV_BIT 4 +#define CPM_CPCCR_HDIV_MASK (0x0f << CPM_CPCCR_HDIV_BIT) +#define CPM_CPCCR_CDIV_BIT 0 +#define CPM_CPCCR_CDIV_MASK (0x0f << CPM_CPCCR_CDIV_BIT) + +/* I2S Clock Divider Register */ +#define CPM_I2SCDR_I2SDIV_BIT 0 +#define CPM_I2SCDR_I2SDIV_MASK (0x1ff << CPM_I2SCDR_I2SDIV_BIT) + +/* LCD Pixel Clock Divider Register */ +#define CPM_LPCDR_PIXDIV_BIT 0 +#define CPM_LPCDR_PIXDIV_MASK (0x1ff << CPM_LPCDR_PIXDIV_BIT) + +/* MSC Clock Divider Register */ +#define CPM_MSCCDR_MSCDIV_BIT 0 +#define CPM_MSCCDR_MSCDIV_MASK (0x1f << CPM_MSCCDR_MSCDIV_BIT) + +/* PLL Control Register */ +#define CPM_CPPCR_PLLM_BIT 23 +#define CPM_CPPCR_PLLM_MASK (0x1ff << CPM_CPPCR_PLLM_BIT) +#define CPM_CPPCR_PLLN_BIT 18 +#define CPM_CPPCR_PLLN_MASK (0x1f << CPM_CPPCR_PLLN_BIT) +#define CPM_CPPCR_PLLOD_BIT 16 +#define CPM_CPPCR_PLLOD_MASK (0x03 << CPM_CPPCR_PLLOD_BIT) +#define CPM_CPPCR_PLLS (1 << 10) +#define CPM_CPPCR_PLLBP (1 << 9) +#define CPM_CPPCR_PLLEN (1 << 8) +#define CPM_CPPCR_PLLST_BIT 0 +#define CPM_CPPCR_PLLST_MASK (0xff << CPM_CPPCR_PLLST_BIT) + +/* Low Power Control Register */ +#define CPM_LCR_DOZE_DUTY_BIT 3 +#define CPM_LCR_DOZE_DUTY_MASK (0x1f << CPM_LCR_DOZE_DUTY_BIT) +#define CPM_LCR_DOZE_ON (1 << 2) +#define CPM_LCR_LPM_BIT 0 +#define CPM_LCR_LPM_MASK (0x3 << CPM_LCR_LPM_BIT) + #define CPM_LCR_LPM_IDLE (0x0 << CPM_LCR_LPM_BIT) + #define CPM_LCR_LPM_SLEEP (0x1 << CPM_LCR_LPM_BIT) + +/* Clock Gate Register */ +#define CPM_CLKGR_UART1 (1 << 15) +#define CPM_CLKGR_UHC (1 << 14) +#define CPM_CLKGR_IPU (1 << 13) +#define CPM_CLKGR_DMAC (1 << 12) +#define CPM_CLKGR_UDC (1 << 11) +#define CPM_CLKGR_LCD (1 << 10) +#define CPM_CLKGR_CIM (1 << 9) +#define CPM_CLKGR_SADC (1 << 8) +#define CPM_CLKGR_MSC (1 << 7) +#define CPM_CLKGR_AIC1 (1 << 6) +#define CPM_CLKGR_AIC2 (1 << 5) +#define CPM_CLKGR_SSI (1 << 4) +#define CPM_CLKGR_I2C (1 << 3) +#define CPM_CLKGR_RTC (1 << 2) +#define CPM_CLKGR_TCU (1 << 1) +#define CPM_CLKGR_UART0 (1 << 0) + +/* Sleep Control Register */ +#define CPM_SCR_O1ST_BIT 8 +#define CPM_SCR_O1ST_MASK (0xff << CPM_SCR_O1ST_BIT) +#define CPM_SCR_USBPHY_ENABLE (1 << 6) +#define CPM_SCR_OSC_ENABLE (1 << 4) + +/* Hibernate Control Register */ +#define CPM_HCR_PD (1 << 0) + +/* Wakeup Filter Counter Register in Hibernate Mode */ +#define CPM_HWFCR_TIME_BIT 0 +#define CPM_HWFCR_TIME_MASK (0x3ff << CPM_HWFCR_TIME_BIT) + +/* Reset Counter Register in Hibernate Mode */ +#define CPM_HRCR_TIME_BIT 0 +#define CPM_HRCR_TIME_MASK (0x7f << CPM_HRCR_TIME_BIT) + +/* Wakeup Control Register in Hibernate Mode */ +#define CPM_HWCR_WLE_LOW (0 << 2) +#define CPM_HWCR_WLE_HIGH (1 << 2) +#define CPM_HWCR_PIN_WAKEUP (1 << 1) +#define CPM_HWCR_RTC_WAKEUP (1 << 0) + +/* Wakeup Status Register in Hibernate Mode */ +#define CPM_HWSR_WSR_PIN (1 << 1) +#define CPM_HWSR_WSR_RTC (1 << 0) + +/* Reset Status Register */ +#define CPM_RSR_HR (1 << 2) +#define CPM_RSR_WR (1 << 1) +#define CPM_RSR_PR (1 << 0) + + +/************************************************************************* + * TCU (Timer Counter Unit) + *************************************************************************/ +#define TCU_TSR (TCU_BASE + 0x1C) /* Timer Stop Register */ +#define TCU_TSSR (TCU_BASE + 0x2C) /* Timer Stop Set Register */ +#define TCU_TSCR (TCU_BASE + 0x3C) /* Timer Stop Clear Register */ +#define TCU_TER (TCU_BASE + 0x10) /* Timer Counter Enable Register */ +#define TCU_TESR (TCU_BASE + 0x14) /* Timer Counter Enable Set Register */ +#define TCU_TECR (TCU_BASE + 0x18) /* Timer Counter Enable Clear Register */ +#define TCU_TFR (TCU_BASE + 0x20) /* Timer Flag Register */ +#define TCU_TFSR (TCU_BASE + 0x24) /* Timer Flag Set Register */ +#define TCU_TFCR (TCU_BASE + 0x28) /* Timer Flag Clear Register */ +#define TCU_TMR (TCU_BASE + 0x30) /* Timer Mask Register */ +#define TCU_TMSR (TCU_BASE + 0x34) /* Timer Mask Set Register */ +#define TCU_TMCR (TCU_BASE + 0x38) /* Timer Mask Clear Register */ +#define TCU_TDFR0 (TCU_BASE + 0x40) /* Timer Data Full Register */ +#define TCU_TDHR0 (TCU_BASE + 0x44) /* Timer Data Half Register */ +#define TCU_TCNT0 (TCU_BASE + 0x48) /* Timer Counter Register */ +#define TCU_TCSR0 (TCU_BASE + 0x4C) /* Timer Control Register */ +#define TCU_TDFR1 (TCU_BASE + 0x50) +#define TCU_TDHR1 (TCU_BASE + 0x54) +#define TCU_TCNT1 (TCU_BASE + 0x58) +#define TCU_TCSR1 (TCU_BASE + 0x5C) +#define TCU_TDFR2 (TCU_BASE + 0x60) +#define TCU_TDHR2 (TCU_BASE + 0x64) +#define TCU_TCNT2 (TCU_BASE + 0x68) +#define TCU_TCSR2 (TCU_BASE + 0x6C) +#define TCU_TDFR3 (TCU_BASE + 0x70) +#define TCU_TDHR3 (TCU_BASE + 0x74) +#define TCU_TCNT3 (TCU_BASE + 0x78) +#define TCU_TCSR3 (TCU_BASE + 0x7C) +#define TCU_TDFR4 (TCU_BASE + 0x80) +#define TCU_TDHR4 (TCU_BASE + 0x84) +#define TCU_TCNT4 (TCU_BASE + 0x88) +#define TCU_TCSR4 (TCU_BASE + 0x8C) +#define TCU_TDFR5 (TCU_BASE + 0x90) +#define TCU_TDHR5 (TCU_BASE + 0x94) +#define TCU_TCNT5 (TCU_BASE + 0x98) +#define TCU_TCSR5 (TCU_BASE + 0x9C) + +#define REG_TCU_TSR REG32(TCU_TSR) +#define REG_TCU_TSSR REG32(TCU_TSSR) +#define REG_TCU_TSCR REG32(TCU_TSCR) +#define REG_TCU_TER REG8(TCU_TER) +#define REG_TCU_TESR REG8(TCU_TESR) +#define REG_TCU_TECR REG8(TCU_TECR) +#define REG_TCU_TFR REG32(TCU_TFR) +#define REG_TCU_TFSR REG32(TCU_TFSR) +#define REG_TCU_TFCR REG32(TCU_TFCR) +#define REG_TCU_TMR REG32(TCU_TMR) +#define REG_TCU_TMSR REG32(TCU_TMSR) +#define REG_TCU_TMCR REG32(TCU_TMCR) +#define REG_TCU_TDFR0 REG16(TCU_TDFR0) +#define REG_TCU_TDHR0 REG16(TCU_TDHR0) +#define REG_TCU_TCNT0 REG16(TCU_TCNT0) +#define REG_TCU_TCSR0 REG16(TCU_TCSR0) +#define REG_TCU_TDFR1 REG16(TCU_TDFR1) +#define REG_TCU_TDHR1 REG16(TCU_TDHR1) +#define REG_TCU_TCNT1 REG16(TCU_TCNT1) +#define REG_TCU_TCSR1 REG16(TCU_TCSR1) +#define REG_TCU_TDFR2 REG16(TCU_TDFR2) +#define REG_TCU_TDHR2 REG16(TCU_TDHR2) +#define REG_TCU_TCNT2 REG16(TCU_TCNT2) +#define REG_TCU_TCSR2 REG16(TCU_TCSR2) +#define REG_TCU_TDFR3 REG16(TCU_TDFR3) +#define REG_TCU_TDHR3 REG16(TCU_TDHR3) +#define REG_TCU_TCNT3 REG16(TCU_TCNT3) +#define REG_TCU_TCSR3 REG16(TCU_TCSR3) +#define REG_TCU_TDFR4 REG16(TCU_TDFR4) +#define REG_TCU_TDHR4 REG16(TCU_TDHR4) +#define REG_TCU_TCNT4 REG16(TCU_TCNT4) +#define REG_TCU_TCSR4 REG16(TCU_TCSR4) + +// n = 0,1,2,3,4,5 +#define TCU_TDFR(n) (TCU_BASE + (0x40 + (n)*0x10)) /* Timer Data Full Reg */ +#define TCU_TDHR(n) (TCU_BASE + (0x44 + (n)*0x10)) /* Timer Data Half Reg */ +#define TCU_TCNT(n) (TCU_BASE + (0x48 + (n)*0x10)) /* Timer Counter Reg */ +#define TCU_TCSR(n) (TCU_BASE + (0x4C + (n)*0x10)) /* Timer Control Reg */ + +#define REG_TCU_TDFR(n) REG16(TCU_TDFR((n))) +#define REG_TCU_TDHR(n) REG16(TCU_TDHR((n))) +#define REG_TCU_TCNT(n) REG16(TCU_TCNT((n))) +#define REG_TCU_TCSR(n) REG16(TCU_TCSR((n))) + +// Register definitions +#define TCU_TCSR_PWM_SD (1 << 9) +#define TCU_TCSR_PWM_INITL_HIGH (1 << 8) +#define TCU_TCSR_PWM_EN (1 << 7) +#define TCU_TCSR_PRESCALE_BIT 3 +#define TCU_TCSR_PRESCALE_MASK (0x7 << TCU_TCSR_PRESCALE_BIT) + #define TCU_TCSR_PRESCALE1 (0x0 << TCU_TCSR_PRESCALE_BIT) + #define TCU_TCSR_PRESCALE4 (0x1 << TCU_TCSR_PRESCALE_BIT) + #define TCU_TCSR_PRESCALE16 (0x2 << TCU_TCSR_PRESCALE_BIT) + #define TCU_TCSR_PRESCALE64 (0x3 << TCU_TCSR_PRESCALE_BIT) + #define TCU_TCSR_PRESCALE256 (0x4 << TCU_TCSR_PRESCALE_BIT) + #define TCU_TCSR_PRESCALE1024 (0x5 << TCU_TCSR_PRESCALE_BIT) +#define TCU_TCSR_EXT_EN (1 << 2) +#define TCU_TCSR_RTC_EN (1 << 1) +#define TCU_TCSR_PCK_EN (1 << 0) + +#define TCU_TER_TCEN5 (1 << 5) +#define TCU_TER_TCEN4 (1 << 4) +#define TCU_TER_TCEN3 (1 << 3) +#define TCU_TER_TCEN2 (1 << 2) +#define TCU_TER_TCEN1 (1 << 1) +#define TCU_TER_TCEN0 (1 << 0) + +#define TCU_TESR_TCST5 (1 << 5) +#define TCU_TESR_TCST4 (1 << 4) +#define TCU_TESR_TCST3 (1 << 3) +#define TCU_TESR_TCST2 (1 << 2) +#define TCU_TESR_TCST1 (1 << 1) +#define TCU_TESR_TCST0 (1 << 0) + +#define TCU_TECR_TCCL5 (1 << 5) +#define TCU_TECR_TCCL4 (1 << 4) +#define TCU_TECR_TCCL3 (1 << 3) +#define TCU_TECR_TCCL2 (1 << 2) +#define TCU_TECR_TCCL1 (1 << 1) +#define TCU_TECR_TCCL0 (1 << 0) + +#define TCU_TFR_HFLAG5 (1 << 21) +#define TCU_TFR_HFLAG4 (1 << 20) +#define TCU_TFR_HFLAG3 (1 << 19) +#define TCU_TFR_HFLAG2 (1 << 18) +#define TCU_TFR_HFLAG1 (1 << 17) +#define TCU_TFR_HFLAG0 (1 << 16) +#define TCU_TFR_FFLAG5 (1 << 5) +#define TCU_TFR_FFLAG4 (1 << 4) +#define TCU_TFR_FFLAG3 (1 << 3) +#define TCU_TFR_FFLAG2 (1 << 2) +#define TCU_TFR_FFLAG1 (1 << 1) +#define TCU_TFR_FFLAG0 (1 << 0) + +#define TCU_TFSR_HFLAG5 (1 << 21) +#define TCU_TFSR_HFLAG4 (1 << 20) +#define TCU_TFSR_HFLAG3 (1 << 19) +#define TCU_TFSR_HFLAG2 (1 << 18) +#define TCU_TFSR_HFLAG1 (1 << 17) +#define TCU_TFSR_HFLAG0 (1 << 16) +#define TCU_TFSR_FFLAG5 (1 << 5) +#define TCU_TFSR_FFLAG4 (1 << 4) +#define TCU_TFSR_FFLAG3 (1 << 3) +#define TCU_TFSR_FFLAG2 (1 << 2) +#define TCU_TFSR_FFLAG1 (1 << 1) +#define TCU_TFSR_FFLAG0 (1 << 0) + +#define TCU_TFCR_HFLAG5 (1 << 21) +#define TCU_TFCR_HFLAG4 (1 << 20) +#define TCU_TFCR_HFLAG3 (1 << 19) +#define TCU_TFCR_HFLAG2 (1 << 18) +#define TCU_TFCR_HFLAG1 (1 << 17) +#define TCU_TFCR_HFLAG0 (1 << 16) +#define TCU_TFCR_FFLAG5 (1 << 5) +#define TCU_TFCR_FFLAG4 (1 << 4) +#define TCU_TFCR_FFLAG3 (1 << 3) +#define TCU_TFCR_FFLAG2 (1 << 2) +#define TCU_TFCR_FFLAG1 (1 << 1) +#define TCU_TFCR_FFLAG0 (1 << 0) + +#define TCU_TMR_HMASK5 (1 << 21) +#define TCU_TMR_HMASK4 (1 << 20) +#define TCU_TMR_HMASK3 (1 << 19) +#define TCU_TMR_HMASK2 (1 << 18) +#define TCU_TMR_HMASK1 (1 << 17) +#define TCU_TMR_HMASK0 (1 << 16) +#define TCU_TMR_FMASK5 (1 << 5) +#define TCU_TMR_FMASK4 (1 << 4) +#define TCU_TMR_FMASK3 (1 << 3) +#define TCU_TMR_FMASK2 (1 << 2) +#define TCU_TMR_FMASK1 (1 << 1) +#define TCU_TMR_FMASK0 (1 << 0) + +#define TCU_TMSR_HMST5 (1 << 21) +#define TCU_TMSR_HMST4 (1 << 20) +#define TCU_TMSR_HMST3 (1 << 19) +#define TCU_TMSR_HMST2 (1 << 18) +#define TCU_TMSR_HMST1 (1 << 17) +#define TCU_TMSR_HMST0 (1 << 16) +#define TCU_TMSR_FMST5 (1 << 5) +#define TCU_TMSR_FMST4 (1 << 4) +#define TCU_TMSR_FMST3 (1 << 3) +#define TCU_TMSR_FMST2 (1 << 2) +#define TCU_TMSR_FMST1 (1 << 1) +#define TCU_TMSR_FMST0 (1 << 0) + +#define TCU_TMCR_HMCL5 (1 << 21) +#define TCU_TMCR_HMCL4 (1 << 20) +#define TCU_TMCR_HMCL3 (1 << 19) +#define TCU_TMCR_HMCL2 (1 << 18) +#define TCU_TMCR_HMCL1 (1 << 17) +#define TCU_TMCR_HMCL0 (1 << 16) +#define TCU_TMCR_FMCL5 (1 << 5) +#define TCU_TMCR_FMCL4 (1 << 4) +#define TCU_TMCR_FMCL3 (1 << 3) +#define TCU_TMCR_FMCL2 (1 << 2) +#define TCU_TMCR_FMCL1 (1 << 1) +#define TCU_TMCR_FMCL0 (1 << 0) + +#define TCU_TSR_WDTS (1 << 16) +#define TCU_TSR_STOP5 (1 << 5) +#define TCU_TSR_STOP4 (1 << 4) +#define TCU_TSR_STOP3 (1 << 3) +#define TCU_TSR_STOP2 (1 << 2) +#define TCU_TSR_STOP1 (1 << 1) +#define TCU_TSR_STOP0 (1 << 0) + +#define TCU_TSSR_WDTSS (1 << 16) +#define TCU_TSSR_STPS5 (1 << 5) +#define TCU_TSSR_STPS4 (1 << 4) +#define TCU_TSSR_STPS3 (1 << 3) +#define TCU_TSSR_STPS2 (1 << 2) +#define TCU_TSSR_STPS1 (1 << 1) +#define TCU_TSSR_STPS0 (1 << 0) + +#define TCU_TSSR_WDTSC (1 << 16) +#define TCU_TSSR_STPC5 (1 << 5) +#define TCU_TSSR_STPC4 (1 << 4) +#define TCU_TSSR_STPC3 (1 << 3) +#define TCU_TSSR_STPC2 (1 << 2) +#define TCU_TSSR_STPC1 (1 << 1) +#define TCU_TSSR_STPC0 (1 << 0) + + +/************************************************************************* + * WDT (WatchDog Timer) + *************************************************************************/ +#define WDT_TDR (WDT_BASE + 0x00) +#define WDT_TCER (WDT_BASE + 0x04) +#define WDT_TCNT (WDT_BASE + 0x08) +#define WDT_TCSR (WDT_BASE + 0x0C) + +#define REG_WDT_TDR REG16(WDT_TDR) +#define REG_WDT_TCER REG8(WDT_TCER) +#define REG_WDT_TCNT REG16(WDT_TCNT) +#define REG_WDT_TCSR REG16(WDT_TCSR) + +// Register definition +#define WDT_TCSR_PRESCALE_BIT 3 +#define WDT_TCSR_PRESCALE_MASK (0x7 << WDT_TCSR_PRESCALE_BIT) + #define WDT_TCSR_PRESCALE1 (0x0 << WDT_TCSR_PRESCALE_BIT) + #define WDT_TCSR_PRESCALE4 (0x1 << WDT_TCSR_PRESCALE_BIT) + #define WDT_TCSR_PRESCALE16 (0x2 << WDT_TCSR_PRESCALE_BIT) + #define WDT_TCSR_PRESCALE64 (0x3 << WDT_TCSR_PRESCALE_BIT) + #define WDT_TCSR_PRESCALE256 (0x4 << WDT_TCSR_PRESCALE_BIT) + #define WDT_TCSR_PRESCALE1024 (0x5 << WDT_TCSR_PRESCALE_BIT) +#define WDT_TCSR_EXT_EN (1 << 2) +#define WDT_TCSR_RTC_EN (1 << 1) +#define WDT_TCSR_PCK_EN (1 << 0) + +#define WDT_TCER_TCEN (1 << 0) + + +/************************************************************************* + * DMAC (DMA Controller) + *************************************************************************/ + +#define MAX_DMA_NUM 6 /* max 6 channels */ + +#define DMAC_DSAR(n) (DMAC_BASE + (0x00 + (n) * 0x20)) /* DMA source address */ +#define DMAC_DTAR(n) (DMAC_BASE + (0x04 + (n) * 0x20)) /* DMA target address */ +#define DMAC_DTCR(n) (DMAC_BASE + (0x08 + (n) * 0x20)) /* DMA transfer count */ +#define DMAC_DRSR(n) (DMAC_BASE + (0x0c + (n) * 0x20)) /* DMA request source */ +#define DMAC_DCCSR(n) (DMAC_BASE + (0x10 + (n) * 0x20)) /* DMA control/status */ +#define DMAC_DCMD(n) (DMAC_BASE + (0x14 + (n) * 0x20)) /* DMA command */ +#define DMAC_DDA(n) (DMAC_BASE + (0x18 + (n) * 0x20)) /* DMA descriptor address */ +#define DMAC_DMACR (DMAC_BASE + 0x0300) /* DMA control register */ +#define DMAC_DMAIPR (DMAC_BASE + 0x0304) /* DMA interrupt pending */ +#define DMAC_DMADBR (DMAC_BASE + 0x0308) /* DMA doorbell */ +#define DMAC_DMADBSR (DMAC_BASE + 0x030C) /* DMA doorbell set */ + +// channel 0 +#define DMAC_DSAR0 DMAC_DSAR(0) +#define DMAC_DTAR0 DMAC_DTAR(0) +#define DMAC_DTCR0 DMAC_DTCR(0) +#define DMAC_DRSR0 DMAC_DRSR(0) +#define DMAC_DCCSR0 DMAC_DCCSR(0) +#define DMAC_DCMD0 DMAC_DCMD(0) +#define DMAC_DDA0 DMAC_DDA(0) + +// channel 1 +#define DMAC_DSAR1 DMAC_DSAR(1) +#define DMAC_DTAR1 DMAC_DTAR(1) +#define DMAC_DTCR1 DMAC_DTCR(1) +#define DMAC_DRSR1 DMAC_DRSR(1) +#define DMAC_DCCSR1 DMAC_DCCSR(1) +#define DMAC_DCMD1 DMAC_DCMD(1) +#define DMAC_DDA1 DMAC_DDA(1) + +// channel 2 +#define DMAC_DSAR2 DMAC_DSAR(2) +#define DMAC_DTAR2 DMAC_DTAR(2) +#define DMAC_DTCR2 DMAC_DTCR(2) +#define DMAC_DRSR2 DMAC_DRSR(2) +#define DMAC_DCCSR2 DMAC_DCCSR(2) +#define DMAC_DCMD2 DMAC_DCMD(2) +#define DMAC_DDA2 DMAC_DDA(2) + +// channel 3 +#define DMAC_DSAR3 DMAC_DSAR(3) +#define DMAC_DTAR3 DMAC_DTAR(3) +#define DMAC_DTCR3 DMAC_DTCR(3) +#define DMAC_DRSR3 DMAC_DRSR(3) +#define DMAC_DCCSR3 DMAC_DCCSR(3) +#define DMAC_DCMD3 DMAC_DCMD(3) +#define DMAC_DDA3 DMAC_DDA(3) + +// channel 4 +#define DMAC_DSAR4 DMAC_DSAR(4) +#define DMAC_DTAR4 DMAC_DTAR(4) +#define DMAC_DTCR4 DMAC_DTCR(4) +#define DMAC_DRSR4 DMAC_DRSR(4) +#define DMAC_DCCSR4 DMAC_DCCSR(4) +#define DMAC_DCMD4 DMAC_DCMD(4) +#define DMAC_DDA4 DMAC_DDA(4) + +// channel 5 +#define DMAC_DSAR5 DMAC_DSAR(5) +#define DMAC_DTAR5 DMAC_DTAR(5) +#define DMAC_DTCR5 DMAC_DTCR(5) +#define DMAC_DRSR5 DMAC_DRSR(5) +#define DMAC_DCCSR5 DMAC_DCCSR(5) +#define DMAC_DCMD5 DMAC_DCMD(5) +#define DMAC_DDA5 DMAC_DDA(5) + +#define REG_DMAC_DSAR(n) REG32(DMAC_DSAR((n))) +#define REG_DMAC_DTAR(n) REG32(DMAC_DTAR((n))) +#define REG_DMAC_DTCR(n) REG32(DMAC_DTCR((n))) +#define REG_DMAC_DRSR(n) REG32(DMAC_DRSR((n))) +#define REG_DMAC_DCCSR(n) REG32(DMAC_DCCSR((n))) +#define REG_DMAC_DCMD(n) REG32(DMAC_DCMD((n))) +#define REG_DMAC_DDA(n) REG32(DMAC_DDA((n))) +#define REG_DMAC_DMACR REG32(DMAC_DMACR) +#define REG_DMAC_DMAIPR REG32(DMAC_DMAIPR) +#define REG_DMAC_DMADBR REG32(DMAC_DMADBR) +#define REG_DMAC_DMADBSR REG32(DMAC_DMADBSR) + +// DMA request source register +#define DMAC_DRSR_RS_BIT 0 +#define DMAC_DRSR_RS_MASK (0x1f << DMAC_DRSR_RS_BIT) + #define DMAC_DRSR_RS_AUTO (8 << DMAC_DRSR_RS_BIT) + #define DMAC_DRSR_RS_UART0OUT (20 << DMAC_DRSR_RS_BIT) + #define DMAC_DRSR_RS_UART0IN (21 << DMAC_DRSR_RS_BIT) + #define DMAC_DRSR_RS_SSIOUT (22 << DMAC_DRSR_RS_BIT) + #define DMAC_DRSR_RS_SSIIN (23 << DMAC_DRSR_RS_BIT) + #define DMAC_DRSR_RS_AICOUT (24 << DMAC_DRSR_RS_BIT) + #define DMAC_DRSR_RS_AICIN (25 << DMAC_DRSR_RS_BIT) + #define DMAC_DRSR_RS_MSCOUT (26 << DMAC_DRSR_RS_BIT) + #define DMAC_DRSR_RS_MSCIN (27 << DMAC_DRSR_RS_BIT) + #define DMAC_DRSR_RS_TCU (28 << DMAC_DRSR_RS_BIT) + #define DMAC_DRSR_RS_SADC (29 << DMAC_DRSR_RS_BIT) + #define DMAC_DRSR_RS_SLCD (30 << DMAC_DRSR_RS_BIT) + +// DMA channel control/status register +#define DMAC_DCCSR_NDES (1 << 31) /* descriptor (0) or not (1) ? */ +#define DMAC_DCCSR_CDOA_BIT 16 /* copy of DMA offset address */ +#define DMAC_DCCSR_CDOA_MASK (0xff << DMAC_DCCSR_CDOA_BIT) +#define DMAC_DCCSR_INV (1 << 6) /* descriptor invalid */ +#define DMAC_DCCSR_AR (1 << 4) /* address error */ +#define DMAC_DCCSR_TT (1 << 3) /* transfer terminated */ +#define DMAC_DCCSR_HLT (1 << 2) /* DMA halted */ +#define DMAC_DCCSR_CT (1 << 1) /* count terminated */ +#define DMAC_DCCSR_EN (1 << 0) /* channel enable bit */ + +// DMA channel command register +#define DMAC_DCMD_SAI (1 << 23) /* source address increment */ +#define DMAC_DCMD_DAI (1 << 22) /* dest address increment */ +#define DMAC_DCMD_RDIL_BIT 16 /* request detection interval length */ +#define DMAC_DCMD_RDIL_MASK (0x0f << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_IGN (0 << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_2 (1 << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_4 (2 << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_8 (3 << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_12 (4 << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_16 (5 << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_20 (6 << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_24 (7 << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_28 (8 << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_32 (9 << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_48 (10 << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_60 (11 << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_64 (12 << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_124 (13 << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_128 (14 << DMAC_DCMD_RDIL_BIT) + #define DMAC_DCMD_RDIL_200 (15 << DMAC_DCMD_RDIL_BIT) +#define DMAC_DCMD_SWDH_BIT 14 /* source port width */ +#define DMAC_DCMD_SWDH_MASK (0x03 << DMAC_DCMD_SWDH_BIT) + #define DMAC_DCMD_SWDH_32 (0 << DMAC_DCMD_SWDH_BIT) + #define DMAC_DCMD_SWDH_8 (1 << DMAC_DCMD_SWDH_BIT) + #define DMAC_DCMD_SWDH_16 (2 << DMAC_DCMD_SWDH_BIT) +#define DMAC_DCMD_DWDH_BIT 12 /* dest port width */ +#define DMAC_DCMD_DWDH_MASK (0x03 << DMAC_DCMD_DWDH_BIT) + #define DMAC_DCMD_DWDH_32 (0 << DMAC_DCMD_DWDH_BIT) + #define DMAC_DCMD_DWDH_8 (1 << DMAC_DCMD_DWDH_BIT) + #define DMAC_DCMD_DWDH_16 (2 << DMAC_DCMD_DWDH_BIT) +#define DMAC_DCMD_DS_BIT 8 /* transfer data size of a data unit */ +#define DMAC_DCMD_DS_MASK (0x07 << DMAC_DCMD_DS_BIT) + #define DMAC_DCMD_DS_32BIT (0 << DMAC_DCMD_DS_BIT) + #define DMAC_DCMD_DS_8BIT (1 << DMAC_DCMD_DS_BIT) + #define DMAC_DCMD_DS_16BIT (2 << DMAC_DCMD_DS_BIT) + #define DMAC_DCMD_DS_16BYTE (3 << DMAC_DCMD_DS_BIT) + #define DMAC_DCMD_DS_32BYTE (4 << DMAC_DCMD_DS_BIT) +#define DMAC_DCMD_TM (1 << 7) /* transfer mode: 0-single 1-block */ +#define DMAC_DCMD_DES_V (1 << 4) /* descriptor valid flag */ +#define DMAC_DCMD_DES_VM (1 << 3) /* descriptor valid mask: 1:support V-bit */ +#define DMAC_DCMD_DES_VIE (1 << 2) /* DMA valid error interrupt enable */ +#define DMAC_DCMD_TIE (1 << 1) /* DMA transfer interrupt enable */ +#define DMAC_DCMD_LINK (1 << 0) /* descriptor link enable */ + +// DMA descriptor address register +#define DMAC_DDA_BASE_BIT 12 /* descriptor base address */ +#define DMAC_DDA_BASE_MASK (0x0fffff << DMAC_DDA_BASE_BIT) +#define DMAC_DDA_OFFSET_BIT 4 /* descriptor offset address */ +#define DMAC_DDA_OFFSET_MASK (0x0ff << DMAC_DDA_OFFSET_BIT) + +// DMA control register +#define DMAC_DMACR_PR_BIT 8 /* channel priority mode */ +#define DMAC_DMACR_PR_MASK (0x03 << DMAC_DMACR_PR_BIT) + #define DMAC_DMACR_PR_012345 (0 << DMAC_DMACR_PR_BIT) + #define DMAC_DMACR_PR_023145 (1 << DMAC_DMACR_PR_BIT) + #define DMAC_DMACR_PR_201345 (2 << DMAC_DMACR_PR_BIT) + #define DMAC_DMACR_PR_RR (3 << DMAC_DMACR_PR_BIT) /* round robin */ +#define DMAC_DMACR_HLT (1 << 3) /* DMA halt flag */ +#define DMAC_DMACR_AR (1 << 2) /* address error flag */ +#define DMAC_DMACR_DMAE (1 << 0) /* DMA enable bit */ + +// DMA doorbell register +#define DMAC_DMADBR_DB5 (1 << 5) /* doorbell for channel 5 */ +#define DMAC_DMADBR_DB4 (1 << 5) /* doorbell for channel 4 */ +#define DMAC_DMADBR_DB3 (1 << 5) /* doorbell for channel 3 */ +#define DMAC_DMADBR_DB2 (1 << 5) /* doorbell for channel 2 */ +#define DMAC_DMADBR_DB1 (1 << 5) /* doorbell for channel 1 */ +#define DMAC_DMADBR_DB0 (1 << 5) /* doorbell for channel 0 */ + +// DMA doorbell set register +#define DMAC_DMADBSR_DBS5 (1 << 5) /* enable doorbell for channel 5 */ +#define DMAC_DMADBSR_DBS4 (1 << 5) /* enable doorbell for channel 4 */ +#define DMAC_DMADBSR_DBS3 (1 << 5) /* enable doorbell for channel 3 */ +#define DMAC_DMADBSR_DBS2 (1 << 5) /* enable doorbell for channel 2 */ +#define DMAC_DMADBSR_DBS1 (1 << 5) /* enable doorbell for channel 1 */ +#define DMAC_DMADBSR_DBS0 (1 << 5) /* enable doorbell for channel 0 */ + +// DMA interrupt pending register +#define DMAC_DMAIPR_CIRQ5 (1 << 5) /* irq pending status for channel 5 */ +#define DMAC_DMAIPR_CIRQ4 (1 << 4) /* irq pending status for channel 4 */ +#define DMAC_DMAIPR_CIRQ3 (1 << 3) /* irq pending status for channel 3 */ +#define DMAC_DMAIPR_CIRQ2 (1 << 2) /* irq pending status for channel 2 */ +#define DMAC_DMAIPR_CIRQ1 (1 << 1) /* irq pending status for channel 1 */ +#define DMAC_DMAIPR_CIRQ0 (1 << 0) /* irq pending status for channel 0 */ + + +/************************************************************************* + * GPIO (General-Purpose I/O Ports) + *************************************************************************/ +#define MAX_GPIO_NUM 128 + +//n = 0,1,2,3 +#define GPIO_PXPIN(n) (GPIO_BASE + (0x00 + (n)*0x100)) /* PIN Level Register */ +#define GPIO_PXDAT(n) (GPIO_BASE + (0x10 + (n)*0x100)) /* Port Data Register */ +#define GPIO_PXDATS(n) (GPIO_BASE + (0x14 + (n)*0x100)) /* Port Data Set Register */ +#define GPIO_PXDATC(n) (GPIO_BASE + (0x18 + (n)*0x100)) /* Port Data Clear Register */ +#define GPIO_PXIM(n) (GPIO_BASE + (0x20 + (n)*0x100)) /* Interrupt Mask Register */ +#define GPIO_PXIMS(n) (GPIO_BASE + (0x24 + (n)*0x100)) /* Interrupt Mask Set Reg */ +#define GPIO_PXIMC(n) (GPIO_BASE + (0x28 + (n)*0x100)) /* Interrupt Mask Clear Reg */ +#define GPIO_PXPE(n) (GPIO_BASE + (0x30 + (n)*0x100)) /* Pull Enable Register */ +#define GPIO_PXPES(n) (GPIO_BASE + (0x34 + (n)*0x100)) /* Pull Enable Set Reg. */ +#define GPIO_PXPEC(n) (GPIO_BASE + (0x38 + (n)*0x100)) /* Pull Enable Clear Reg. */ +#define GPIO_PXFUN(n) (GPIO_BASE + (0x40 + (n)*0x100)) /* Function Register */ +#define GPIO_PXFUNS(n) (GPIO_BASE + (0x44 + (n)*0x100)) /* Function Set Register */ +#define GPIO_PXFUNC(n) (GPIO_BASE + (0x48 + (n)*0x100)) /* Function Clear Register */ +#define GPIO_PXSEL(n) (GPIO_BASE + (0x50 + (n)*0x100)) /* Select Register */ +#define GPIO_PXSELS(n) (GPIO_BASE + (0x54 + (n)*0x100)) /* Select Set Register */ +#define GPIO_PXSELC(n) (GPIO_BASE + (0x58 + (n)*0x100)) /* Select Clear Register */ +#define GPIO_PXDIR(n) (GPIO_BASE + (0x60 + (n)*0x100)) /* Direction Register */ +#define GPIO_PXDIRS(n) (GPIO_BASE + (0x64 + (n)*0x100)) /* Direction Set Register */ +#define GPIO_PXDIRC(n) (GPIO_BASE + (0x68 + (n)*0x100)) /* Direction Clear Register */ +#define GPIO_PXTRG(n) (GPIO_BASE + (0x70 + (n)*0x100)) /* Trigger Register */ +#define GPIO_PXTRGS(n) (GPIO_BASE + (0x74 + (n)*0x100)) /* Trigger Set Register */ +#define GPIO_PXTRGC(n) (GPIO_BASE + (0x78 + (n)*0x100)) /* Trigger Set Register */ +#define GPIO_PXFLG(n) (GPIO_BASE + (0x80 + (n)*0x100)) /* Port Flag Register */ + +#define REG_GPIO_PXPIN(n) REG32(GPIO_PXPIN((n))) /* PIN level */ +#define REG_GPIO_PXDAT(n) REG32(GPIO_PXDAT((n))) /* 1: interrupt pending */ +#define REG_GPIO_PXDATS(n) REG32(GPIO_PXDATS((n))) +#define REG_GPIO_PXDATC(n) REG32(GPIO_PXDATC((n))) +#define REG_GPIO_PXIM(n) REG32(GPIO_PXIM((n))) /* 1: mask pin interrupt */ +#define REG_GPIO_PXIMS(n) REG32(GPIO_PXIMS((n))) +#define REG_GPIO_PXIMC(n) REG32(GPIO_PXIMC((n))) +#define REG_GPIO_PXPE(n) REG32(GPIO_PXPE((n))) /* 1: disable pull up/down */ +#define REG_GPIO_PXPES(n) REG32(GPIO_PXPES((n))) +#define REG_GPIO_PXPEC(n) REG32(GPIO_PXPEC((n))) +#define REG_GPIO_PXFUN(n) REG32(GPIO_PXFUN((n))) /* 0:GPIO or intr, 1:FUNC */ +#define REG_GPIO_PXFUNS(n) REG32(GPIO_PXFUNS((n))) +#define REG_GPIO_PXFUNC(n) REG32(GPIO_PXFUNC((n))) +#define REG_GPIO_PXSEL(n) REG32(GPIO_PXSEL((n))) /* 0:GPIO/Fun0,1:intr/fun1*/ +#define REG_GPIO_PXSELS(n) REG32(GPIO_PXSELS((n))) +#define REG_GPIO_PXSELC(n) REG32(GPIO_PXSELC((n))) +#define REG_GPIO_PXDIR(n) REG32(GPIO_PXDIR((n))) /* 0:input/low-level-trig/falling-edge-trig, 1:output/high-level-trig/rising-edge-trig */ +#define REG_GPIO_PXDIRS(n) REG32(GPIO_PXDIRS((n))) +#define REG_GPIO_PXDIRC(n) REG32(GPIO_PXDIRC((n))) +#define REG_GPIO_PXTRG(n) REG32(GPIO_PXTRG((n))) /* 0:level-trigger, 1:edge-trigger */ +#define REG_GPIO_PXTRGS(n) REG32(GPIO_PXTRGS((n))) +#define REG_GPIO_PXTRGC(n) REG32(GPIO_PXTRGC((n))) +#define REG_GPIO_PXFLG(n) REG32(GPIO_PXFLG((n))) /* interrupt flag */ + + +/************************************************************************* + * UART + *************************************************************************/ + +#define IRDA_BASE UART0_BASE +#define UART_BASE UART0_BASE +#define UART_OFF 0x1000 + +/* Register Offset */ +#define OFF_RDR (0x00) /* R 8b H'xx */ +#define OFF_TDR (0x00) /* W 8b H'xx */ +#define OFF_DLLR (0x00) /* RW 8b H'00 */ +#define OFF_DLHR (0x04) /* RW 8b H'00 */ +#define OFF_IER (0x04) /* RW 8b H'00 */ +#define OFF_ISR (0x08) /* R 8b H'01 */ +#define OFF_FCR (0x08) /* W 8b H'00 */ +#define OFF_LCR (0x0C) /* RW 8b H'00 */ +#define OFF_MCR (0x10) /* RW 8b H'00 */ +#define OFF_LSR (0x14) /* R 8b H'00 */ +#define OFF_MSR (0x18) /* R 8b H'00 */ +#define OFF_SPR (0x1C) /* RW 8b H'00 */ +#define OFF_SIRCR (0x20) /* RW 8b H'00, UART0 */ +#define OFF_UMR (0x24) /* RW 8b H'00, UART M Register */ +#define OFF_UACR (0x28) /* RW 8b H'00, UART Add Cycle Register */ + +/* Register Address */ +#define UART0_RDR (UART0_BASE + OFF_RDR) +#define UART0_TDR (UART0_BASE + OFF_TDR) +#define UART0_DLLR (UART0_BASE + OFF_DLLR) +#define UART0_DLHR (UART0_BASE + OFF_DLHR) +#define UART0_IER (UART0_BASE + OFF_IER) +#define UART0_ISR (UART0_BASE + OFF_ISR) +#define UART0_FCR (UART0_BASE + OFF_FCR) +#define UART0_LCR (UART0_BASE + OFF_LCR) +#define UART0_MCR (UART0_BASE + OFF_MCR) +#define UART0_LSR (UART0_BASE + OFF_LSR) +#define UART0_MSR (UART0_BASE + OFF_MSR) +#define UART0_SPR (UART0_BASE + OFF_SPR) +#define UART0_SIRCR (UART0_BASE + OFF_SIRCR) +#define UART0_UMR (UART0_BASE + OFF_UMR) +#define UART0_UACR (UART0_BASE + OFF_UACR) + +/* + * Define macros for UART_IER + * UART Interrupt Enable Register + */ +#define UART_IER_RIE (1 << 0) /* 0: receive fifo "full" interrupt disable */ +#define UART_IER_TIE (1 << 1) /* 0: transmit fifo "empty" interrupt disable */ +#define UART_IER_RLIE (1 << 2) /* 0: receive line status interrupt disable */ +#define UART_IER_MIE (1 << 3) /* 0: modem status interrupt disable */ +#define UART_IER_RTIE (1 << 4) /* 0: receive timeout interrupt disable */ + +/* + * Define macros for UART_ISR + * UART Interrupt Status Register + */ +#define UART_ISR_IP (1 << 0) /* 0: interrupt is pending 1: no interrupt */ +#define UART_ISR_IID (7 << 1) /* Source of Interrupt */ +#define UART_ISR_IID_MSI (0 << 1) /* Modem status interrupt */ +#define UART_ISR_IID_THRI (1 << 1) /* Transmitter holding register empty */ +#define UART_ISR_IID_RDI (2 << 1) /* Receiver data interrupt */ +#define UART_ISR_IID_RLSI (3 << 1) /* Receiver line status interrupt */ +#define UART_ISR_FFMS (3 << 6) /* FIFO mode select, set when UART_FCR.FE is set to 1 */ +#define UART_ISR_FFMS_NO_FIFO (0 << 6) +#define UART_ISR_FFMS_FIFO_MODE (3 << 6) + +/* + * Define macros for UART_FCR + * UART FIFO Control Register + */ +#define UART_FCR_FE (1 << 0) /* 0: non-FIFO mode 1: FIFO mode */ +#define UART_FCR_RFLS (1 << 1) /* write 1 to flush receive FIFO */ +#define UART_FCR_TFLS (1 << 2) /* write 1 to flush transmit FIFO */ +#define UART_FCR_DMS (1 << 3) /* 0: disable DMA mode */ +#define UART_FCR_UUE (1 << 4) /* 0: disable UART */ +#define UART_FCR_RTRG (3 << 6) /* Receive FIFO Data Trigger */ +#define UART_FCR_RTRG_1 (0 << 6) +#define UART_FCR_RTRG_4 (1 << 6) +#define UART_FCR_RTRG_8 (2 << 6) +#define UART_FCR_RTRG_15 (3 << 6) + +/* + * Define macros for UART_LCR + * UART Line Control Register + */ +#define UART_LCR_WLEN (3 << 0) /* word length */ +#define UART_LCR_WLEN_5 (0 << 0) +#define UART_LCR_WLEN_6 (1 << 0) +#define UART_LCR_WLEN_7 (2 << 0) +#define UART_LCR_WLEN_8 (3 << 0) +#define UART_LCR_STOP (1 << 2) /* 0: 1 stop bit when word length is 5,6,7,8 + 1: 1.5 stop bits when 5; 2 stop bits when 6,7,8 */ +#define UART_LCR_STOP_1 (0 << 2) /* 0: 1 stop bit when word length is 5,6,7,8 + 1: 1.5 stop bits when 5; 2 stop bits when 6,7,8 */ +#define UART_LCR_STOP_2 (1 << 2) /* 0: 1 stop bit when word length is 5,6,7,8 + 1: 1.5 stop bits when 5; 2 stop bits when 6,7,8 */ + +#define UART_LCR_PE (1 << 3) /* 0: parity disable */ +#define UART_LCR_PROE (1 << 4) /* 0: even parity 1: odd parity */ +#define UART_LCR_SPAR (1 << 5) /* 0: sticky parity disable */ +#define UART_LCR_SBRK (1 << 6) /* write 0 normal, write 1 send break */ +#define UART_LCR_DLAB (1 << 7) /* 0: access UART_RDR/TDR/IER 1: access UART_DLLR/DLHR */ + +/* + * Define macros for UART_LSR + * UART Line Status Register + */ +#define UART_LSR_DR (1 << 0) /* 0: receive FIFO is empty 1: receive data is ready */ +#define UART_LSR_ORER (1 << 1) /* 0: no overrun error */ +#define UART_LSR_PER (1 << 2) /* 0: no parity error */ +#define UART_LSR_FER (1 << 3) /* 0; no framing error */ +#define UART_LSR_BRK (1 << 4) /* 0: no break detected 1: receive a break signal */ +#define UART_LSR_TDRQ (1 << 5) /* 1: transmit FIFO half "empty" */ +#define UART_LSR_TEMT (1 << 6) /* 1: transmit FIFO and shift registers empty */ +#define UART_LSR_RFER (1 << 7) /* 0: no receive error 1: receive error in FIFO mode */ + +/* + * Define macros for UART_MCR + * UART Modem Control Register + */ +#define UART_MCR_DTR (1 << 0) /* 0: DTR_ ouput high */ +#define UART_MCR_RTS (1 << 1) /* 0: RTS_ output high */ +#define UART_MCR_OUT1 (1 << 2) /* 0: UART_MSR.RI is set to 0 and RI_ input high */ +#define UART_MCR_OUT2 (1 << 3) /* 0: UART_MSR.DCD is set to 0 and DCD_ input high */ +#define UART_MCR_LOOP (1 << 4) /* 0: normal 1: loopback mode */ +#define UART_MCR_MCE (1 << 7) /* 0: modem function is disable */ + +/* + * Define macros for UART_MSR + * UART Modem Status Register + */ +#define UART_MSR_DCTS (1 << 0) /* 0: no change on CTS_ pin since last read of UART_MSR */ +#define UART_MSR_DDSR (1 << 1) /* 0: no change on DSR_ pin since last read of UART_MSR */ +#define UART_MSR_DRI (1 << 2) /* 0: no change on RI_ pin since last read of UART_MSR */ +#define UART_MSR_DDCD (1 << 3) /* 0: no change on DCD_ pin since last read of UART_MSR */ +#define UART_MSR_CTS (1 << 4) /* 0: CTS_ pin is high */ +#define UART_MSR_DSR (1 << 5) /* 0: DSR_ pin is high */ +#define UART_MSR_RI (1 << 6) /* 0: RI_ pin is high */ +#define UART_MSR_DCD (1 << 7) /* 0: DCD_ pin is high */ + +/* + * Define macros for SIRCR + * Slow IrDA Control Register + */ +#define SIRCR_TSIRE (1 << 0) /* 0: transmitter is in UART mode 1: IrDA mode */ +#define SIRCR_RSIRE (1 << 1) /* 0: receiver is in UART mode 1: IrDA mode */ +#define SIRCR_TPWS (1 << 2) /* 0: transmit 0 pulse width is 3/16 of bit length + 1: 0 pulse width is 1.6us for 115.2Kbps */ +#define SIRCR_TXPL (1 << 3) /* 0: encoder generates a positive pulse for 0 */ +#define SIRCR_RXPL (1 << 4) /* 0: decoder interprets positive pulse as 0 */ + + +/************************************************************************* + * AIC (AC97/I2S Controller) + *************************************************************************/ +#define AIC_FR (AIC_BASE + 0x000) +#define AIC_CR (AIC_BASE + 0x004) +#define AIC_ACCR1 (AIC_BASE + 0x008) +#define AIC_ACCR2 (AIC_BASE + 0x00C) +#define AIC_I2SCR (AIC_BASE + 0x010) +#define AIC_SR (AIC_BASE + 0x014) +#define AIC_ACSR (AIC_BASE + 0x018) +#define AIC_I2SSR (AIC_BASE + 0x01C) +#define AIC_ACCAR (AIC_BASE + 0x020) +#define AIC_ACCDR (AIC_BASE + 0x024) +#define AIC_ACSAR (AIC_BASE + 0x028) +#define AIC_ACSDR (AIC_BASE + 0x02C) +#define AIC_I2SDIV (AIC_BASE + 0x030) +#define AIC_DR (AIC_BASE + 0x034) + +#define REG_AIC_FR REG32(AIC_FR) +#define REG_AIC_CR REG32(AIC_CR) +#define REG_AIC_ACCR1 REG32(AIC_ACCR1) +#define REG_AIC_ACCR2 REG32(AIC_ACCR2) +#define REG_AIC_I2SCR REG32(AIC_I2SCR) +#define REG_AIC_SR REG32(AIC_SR) +#define REG_AIC_ACSR REG32(AIC_ACSR) +#define REG_AIC_I2SSR REG32(AIC_I2SSR) +#define REG_AIC_ACCAR REG32(AIC_ACCAR) +#define REG_AIC_ACCDR REG32(AIC_ACCDR) +#define REG_AIC_ACSAR REG32(AIC_ACSAR) +#define REG_AIC_ACSDR REG32(AIC_ACSDR) +#define REG_AIC_I2SDIV REG32(AIC_I2SDIV) +#define REG_AIC_DR REG32(AIC_DR) + +/* AIC Controller Configuration Register (AIC_FR) */ + +#define AIC_FR_RFTH_BIT 12 /* Receive FIFO Threshold */ +#define AIC_FR_RFTH_MASK (0xf << AIC_FR_RFTH_BIT) +#define AIC_FR_TFTH_BIT 8 /* Transmit FIFO Threshold */ +#define AIC_FR_TFTH_MASK (0xf << AIC_FR_TFTH_BIT) +#define AIC_FR_ICDC (1 << 5) /* External(0) or Internal CODEC(1) */ +#define AIC_FR_AUSEL (1 << 4) /* AC97(0) or I2S/MSB-justified(1) */ +#define AIC_FR_RST (1 << 3) /* AIC registers reset */ +#define AIC_FR_BCKD (1 << 2) /* I2S BIT_CLK direction, 0:input,1:output */ +#define AIC_FR_SYNCD (1 << 1) /* I2S SYNC direction, 0:input,1:output */ +#define AIC_FR_ENB (1 << 0) /* AIC enable bit */ + +/* AIC Controller Common Control Register (AIC_CR) */ + +#define AIC_CR_OSS_BIT 19 /* Output Sample Size from memory (AIC V2 only) */ +#define AIC_CR_OSS_MASK (0x7 << AIC_CR_OSS_BIT) + #define AIC_CR_OSS_8BIT (0x0 << AIC_CR_OSS_BIT) + #define AIC_CR_OSS_16BIT (0x1 << AIC_CR_OSS_BIT) + #define AIC_CR_OSS_18BIT (0x2 << AIC_CR_OSS_BIT) + #define AIC_CR_OSS_20BIT (0x3 << AIC_CR_OSS_BIT) + #define AIC_CR_OSS_24BIT (0x4 << AIC_CR_OSS_BIT) +#define AIC_CR_ISS_BIT 16 /* Input Sample Size from memory (AIC V2 only) */ +#define AIC_CR_ISS_MASK (0x7 << AIC_CR_ISS_BIT) + #define AIC_CR_ISS_8BIT (0x0 << AIC_CR_ISS_BIT) + #define AIC_CR_ISS_16BIT (0x1 << AIC_CR_ISS_BIT) + #define AIC_CR_ISS_18BIT (0x2 << AIC_CR_ISS_BIT) + #define AIC_CR_ISS_20BIT (0x3 << AIC_CR_ISS_BIT) + #define AIC_CR_ISS_24BIT (0x4 << AIC_CR_ISS_BIT) +#define AIC_CR_RDMS (1 << 15) /* Receive DMA enable */ +#define AIC_CR_TDMS (1 << 14) /* Transmit DMA enable */ +#define AIC_CR_M2S (1 << 11) /* Mono to Stereo enable */ +#define AIC_CR_ENDSW (1 << 10) /* Endian switch enable */ +#define AIC_CR_AVSTSU (1 << 9) /* Signed <-> Unsigned toggle enable */ +#define AIC_CR_FLUSH (1 << 8) /* Flush FIFO */ +#define AIC_CR_EROR (1 << 6) /* Enable ROR interrupt */ +#define AIC_CR_ETUR (1 << 5) /* Enable TUR interrupt */ +#define AIC_CR_ERFS (1 << 4) /* Enable RFS interrupt */ +#define AIC_CR_ETFS (1 << 3) /* Enable TFS interrupt */ +#define AIC_CR_ENLBF (1 << 2) /* Enable Loopback Function */ +#define AIC_CR_ERPL (1 << 1) /* Enable Playback Function */ +#define AIC_CR_EREC (1 << 0) /* Enable Record Function */ + +/* AIC Controller AC-link Control Register 1 (AIC_ACCR1) */ + +#define AIC_ACCR1_RS_BIT 16 /* Receive Valid Slots */ +#define AIC_ACCR1_RS_MASK (0x3ff << AIC_ACCR1_RS_BIT) + #define AIC_ACCR1_RS_SLOT12 (1 << 25) /* Slot 12 valid bit */ + #define AIC_ACCR1_RS_SLOT11 (1 << 24) /* Slot 11 valid bit */ + #define AIC_ACCR1_RS_SLOT10 (1 << 23) /* Slot 10 valid bit */ + #define AIC_ACCR1_RS_SLOT9 (1 << 22) /* Slot 9 valid bit, LFE */ + #define AIC_ACCR1_RS_SLOT8 (1 << 21) /* Slot 8 valid bit, Surround Right */ + #define AIC_ACCR1_RS_SLOT7 (1 << 20) /* Slot 7 valid bit, Surround Left */ + #define AIC_ACCR1_RS_SLOT6 (1 << 19) /* Slot 6 valid bit, PCM Center */ + #define AIC_ACCR1_RS_SLOT5 (1 << 18) /* Slot 5 valid bit */ + #define AIC_ACCR1_RS_SLOT4 (1 << 17) /* Slot 4 valid bit, PCM Right */ + #define AIC_ACCR1_RS_SLOT3 (1 << 16) /* Slot 3 valid bit, PCM Left */ +#define AIC_ACCR1_XS_BIT 0 /* Transmit Valid Slots */ +#define AIC_ACCR1_XS_MASK (0x3ff << AIC_ACCR1_XS_BIT) + #define AIC_ACCR1_XS_SLOT12 (1 << 9) /* Slot 12 valid bit */ + #define AIC_ACCR1_XS_SLOT11 (1 << 8) /* Slot 11 valid bit */ + #define AIC_ACCR1_XS_SLOT10 (1 << 7) /* Slot 10 valid bit */ + #define AIC_ACCR1_XS_SLOT9 (1 << 6) /* Slot 9 valid bit, LFE */ + #define AIC_ACCR1_XS_SLOT8 (1 << 5) /* Slot 8 valid bit, Surround Right */ + #define AIC_ACCR1_XS_SLOT7 (1 << 4) /* Slot 7 valid bit, Surround Left */ + #define AIC_ACCR1_XS_SLOT6 (1 << 3) /* Slot 6 valid bit, PCM Center */ + #define AIC_ACCR1_XS_SLOT5 (1 << 2) /* Slot 5 valid bit */ + #define AIC_ACCR1_XS_SLOT4 (1 << 1) /* Slot 4 valid bit, PCM Right */ + #define AIC_ACCR1_XS_SLOT3 (1 << 0) /* Slot 3 valid bit, PCM Left */ + +/* AIC Controller AC-link Control Register 2 (AIC_ACCR2) */ + +#define AIC_ACCR2_ERSTO (1 << 18) /* Enable RSTO interrupt */ +#define AIC_ACCR2_ESADR (1 << 17) /* Enable SADR interrupt */ +#define AIC_ACCR2_ECADT (1 << 16) /* Enable CADT interrupt */ +#define AIC_ACCR2_OASS_BIT 8 /* Output Sample Size for AC-link */ +#define AIC_ACCR2_OASS_MASK (0x3 << AIC_ACCR2_OASS_BIT) + #define AIC_ACCR2_OASS_20BIT (0 << AIC_ACCR2_OASS_BIT) /* Output Audio Sample Size is 20-bit */ + #define AIC_ACCR2_OASS_18BIT (1 << AIC_ACCR2_OASS_BIT) /* Output Audio Sample Size is 18-bit */ + #define AIC_ACCR2_OASS_16BIT (2 << AIC_ACCR2_OASS_BIT) /* Output Audio Sample Size is 16-bit */ + #define AIC_ACCR2_OASS_8BIT (3 << AIC_ACCR2_OASS_BIT) /* Output Audio Sample Size is 8-bit */ +#define AIC_ACCR2_IASS_BIT 6 /* Output Sample Size for AC-link */ +#define AIC_ACCR2_IASS_MASK (0x3 << AIC_ACCR2_IASS_BIT) + #define AIC_ACCR2_IASS_20BIT (0 << AIC_ACCR2_IASS_BIT) /* Input Audio Sample Size is 20-bit */ + #define AIC_ACCR2_IASS_18BIT (1 << AIC_ACCR2_IASS_BIT) /* Input Audio Sample Size is 18-bit */ + #define AIC_ACCR2_IASS_16BIT (2 << AIC_ACCR2_IASS_BIT) /* Input Audio Sample Size is 16-bit */ + #define AIC_ACCR2_IASS_8BIT (3 << AIC_ACCR2_IASS_BIT) /* Input Audio Sample Size is 8-bit */ +#define AIC_ACCR2_SO (1 << 3) /* SDATA_OUT output value */ +#define AIC_ACCR2_SR (1 << 2) /* RESET# pin level */ +#define AIC_ACCR2_SS (1 << 1) /* SYNC pin level */ +#define AIC_ACCR2_SA (1 << 0) /* SYNC and SDATA_OUT alternation */ + +/* AIC Controller I2S/MSB-justified Control Register (AIC_I2SCR) */ + +#define AIC_I2SCR_STPBK (1 << 12) /* Stop BIT_CLK for I2S/MSB-justified */ +#define AIC_I2SCR_WL_BIT 1 /* Input/Output Sample Size for I2S/MSB-justified */ +#define AIC_I2SCR_WL_MASK (0x7 << AIC_I2SCR_WL_BIT) + #define AIC_I2SCR_WL_24BIT (0 << AIC_I2SCR_WL_BIT) /* Word Length is 24 bit */ + #define AIC_I2SCR_WL_20BIT (1 << AIC_I2SCR_WL_BIT) /* Word Length is 20 bit */ + #define AIC_I2SCR_WL_18BIT (2 << AIC_I2SCR_WL_BIT) /* Word Length is 18 bit */ + #define AIC_I2SCR_WL_16BIT (3 << AIC_I2SCR_WL_BIT) /* Word Length is 16 bit */ + #define AIC_I2SCR_WL_8BIT (4 << AIC_I2SCR_WL_BIT) /* Word Length is 8 bit */ +#define AIC_I2SCR_AMSL (1 << 0) /* 0:I2S, 1:MSB-justified */ + +/* AIC Controller FIFO Status Register (AIC_SR) */ + +#define AIC_SR_RFL_BIT 24 /* Receive FIFO Level */ +#define AIC_SR_RFL_MASK (0x3f << AIC_SR_RFL_BIT) +#define AIC_SR_TFL_BIT 8 /* Transmit FIFO level */ +#define AIC_SR_TFL_MASK (0x3f << AIC_SR_TFL_BIT) +#define AIC_SR_ROR (1 << 6) /* Receive FIFO Overrun */ +#define AIC_SR_TUR (1 << 5) /* Transmit FIFO Underrun */ +#define AIC_SR_RFS (1 << 4) /* Receive FIFO Service Request */ +#define AIC_SR_TFS (1 << 3) /* Transmit FIFO Service Request */ + +/* AIC Controller AC-link Status Register (AIC_ACSR) */ + +#define AIC_ACSR_SLTERR (1 << 21) /* Slot Error Flag */ +#define AIC_ACSR_CRDY (1 << 20) /* External CODEC Ready Flag */ +#define AIC_ACSR_CLPM (1 << 19) /* External CODEC low power mode flag */ +#define AIC_ACSR_RSTO (1 << 18) /* External CODEC regs read status timeout */ +#define AIC_ACSR_SADR (1 << 17) /* External CODEC regs status addr and data received */ +#define AIC_ACSR_CADT (1 << 16) /* Command Address and Data Transmitted */ + +/* AIC Controller I2S/MSB-justified Status Register (AIC_I2SSR) */ + +#define AIC_I2SSR_BSY (1 << 2) /* AIC Busy in I2S/MSB-justified format */ + +/* AIC Controller AC97 codec Command Address Register (AIC_ACCAR) */ + +#define AIC_ACCAR_CAR_BIT 0 +#define AIC_ACCAR_CAR_MASK (0xfffff << AIC_ACCAR_CAR_BIT) + +/* AIC Controller AC97 codec Command Data Register (AIC_ACCDR) */ + +#define AIC_ACCDR_CDR_BIT 0 +#define AIC_ACCDR_CDR_MASK (0xfffff << AIC_ACCDR_CDR_BIT) + +/* AIC Controller AC97 codec Status Address Register (AIC_ACSAR) */ + +#define AIC_ACSAR_SAR_BIT 0 +#define AIC_ACSAR_SAR_MASK (0xfffff << AIC_ACSAR_SAR_BIT) + +/* AIC Controller AC97 codec Status Data Register (AIC_ACSDR) */ + +#define AIC_ACSDR_SDR_BIT 0 +#define AIC_ACSDR_SDR_MASK (0xfffff << AIC_ACSDR_SDR_BIT) + +/* AIC Controller I2S/MSB-justified Clock Divider Register (AIC_I2SDIV) */ + +#define AIC_I2SDIV_DIV_BIT 0 +#define AIC_I2SDIV_DIV_MASK (0x7f << AIC_I2SDIV_DIV_BIT) + #define AIC_I2SDIV_BITCLK_3072KHZ (0x0C << AIC_I2SDIV_DIV_BIT) /* BIT_CLK of 3.072MHz */ + #define AIC_I2SDIV_BITCLK_2836KHZ (0x0D << AIC_I2SDIV_DIV_BIT) /* BIT_CLK of 2.836MHz */ + #define AIC_I2SDIV_BITCLK_1418KHZ (0x1A << AIC_I2SDIV_DIV_BIT) /* BIT_CLK of 1.418MHz */ + #define AIC_I2SDIV_BITCLK_1024KHZ (0x24 << AIC_I2SDIV_DIV_BIT) /* BIT_CLK of 1.024MHz */ + #define AIC_I2SDIV_BITCLK_7089KHZ (0x34 << AIC_I2SDIV_DIV_BIT) /* BIT_CLK of 708.92KHz */ + #define AIC_I2SDIV_BITCLK_512KHZ (0x48 << AIC_I2SDIV_DIV_BIT) /* BIT_CLK of 512.00KHz */ + + +/************************************************************************* + * ICDC (Internal CODEC) + *************************************************************************/ +#define ICDC_CR (ICDC_BASE + 0x0400) /* ICDC Control Register */ +#define ICDC_APWAIT (ICDC_BASE + 0x0404) /* Anti-Pop WAIT Stage Timing Control Register */ +#define ICDC_APPRE (ICDC_BASE + 0x0408) /* Anti-Pop HPEN-PRE Stage Timing Control Register */ +#define ICDC_APHPEN (ICDC_BASE + 0x040C) /* Anti-Pop HPEN Stage Timing Control Register */ +#define ICDC_APSR (ICDC_BASE + 0x0410) /* Anti-Pop Status Register */ +#define ICDC_CDCCR1 (ICDC_BASE + 0x0080) +#define ICDC_CDCCR2 (ICDC_BASE + 0x0084) + +#define REG_ICDC_CR REG32(ICDC_CR) +#define REG_ICDC_APWAIT REG32(ICDC_APWAIT) +#define REG_ICDC_APPRE REG32(ICDC_APPRE) +#define REG_ICDC_APHPEN REG32(ICDC_APHPEN) +#define REG_ICDC_APSR REG32(ICDC_APSR) +#define REG_ICDC_CDCCR1 REG32(ICDC_CDCCR1) +#define REG_ICDC_CDCCR2 REG32(ICDC_CDCCR2) + +/* ICDC Control Register */ +#define ICDC_CR_LINVOL_BIT 24 /* LINE Input Volume Gain: GAIN=LINVOL*1.5-34.5 */ +#define ICDC_CR_LINVOL_MASK (0x1f << ICDC_CR_LINVOL_BIT) +#define ICDC_CR_ASRATE_BIT 20 /* Audio Sample Rate */ +#define ICDC_CR_ASRATE_MASK (0x0f << ICDC_CR_ASRATE_BIT) + #define ICDC_CR_ASRATE_8000 (0x0 << ICDC_CR_ASRATE_BIT) + #define ICDC_CR_ASRATE_11025 (0x1 << ICDC_CR_ASRATE_BIT) + #define ICDC_CR_ASRATE_12000 (0x2 << ICDC_CR_ASRATE_BIT) + #define ICDC_CR_ASRATE_16000 (0x3 << ICDC_CR_ASRATE_BIT) + #define ICDC_CR_ASRATE_22050 (0x4 << ICDC_CR_ASRATE_BIT) + #define ICDC_CR_ASRATE_24000 (0x5 << ICDC_CR_ASRATE_BIT) + #define ICDC_CR_ASRATE_32000 (0x6 << ICDC_CR_ASRATE_BIT) + #define ICDC_CR_ASRATE_44100 (0x7 << ICDC_CR_ASRATE_BIT) + #define ICDC_CR_ASRATE_48000 (0x8 << ICDC_CR_ASRATE_BIT) +#define ICDC_CR_MICBG_BIT 18 /* MIC Boost Gain */ +#define ICDC_CR_MICBG_MASK (0x3 << ICDC_CR_MICBG_BIT) + #define ICDC_CR_MICBG_0DB (0x0 << ICDC_CR_MICBG_BIT) + #define ICDC_CR_MICBG_6DB (0x1 << ICDC_CR_MICBG_BIT) + #define ICDC_CR_MICBG_12DB (0x2 << ICDC_CR_MICBG_BIT) + #define ICDC_CR_MICBG_20DB (0x3 << ICDC_CR_MICBG_BIT) +#define ICDC_CR_HPVOL_BIT 16 /* Headphone Volume Gain */ +#define ICDC_CR_HPVOL_MASK (0x3 << ICDC_CR_HPVOL_BIT) + #define ICDC_CR_HPVOL_0DB (0x0 << ICDC_CR_HPVOL_BIT) + #define ICDC_CR_HPVOL_2DB (0x1 << ICDC_CR_HPVOL_BIT) + #define ICDC_CR_HPVOL_4DB (0x2 << ICDC_CR_HPVOL_BIT) + #define ICDC_CR_HPVOL_6DB (0x3 << ICDC_CR_HPVOL_BIT) +#define ICDC_CR_ELINEIN (1 << 13) /* Enable LINE Input */ +#define ICDC_CR_EMIC (1 << 12) /* Enable MIC Input */ +#define ICDC_CR_SW1ON (1 << 11) /* Switch 1 in CODEC is on */ +#define ICDC_CR_EADC (1 << 10) /* Enable ADC */ +#define ICDC_CR_SW2ON (1 << 9) /* Switch 2 in CODEC is on */ +#define ICDC_CR_EDAC (1 << 8) /* Enable DAC */ +#define ICDC_CR_HPMUTE (1 << 5) /* Headphone Mute */ +#define ICDC_CR_HPTON (1 << 4) /* Headphone Amplifier Trun On */ +#define ICDC_CR_HPTOFF (1 << 3) /* Headphone Amplifier Trun Off */ +#define ICDC_CR_TAAP (1 << 2) /* Turn Around of the Anti-Pop Procedure */ +#define ICDC_CR_EAP (1 << 1) /* Enable Anti-Pop Procedure */ +#define ICDC_CR_SUSPD (1 << 0) /* CODEC Suspend */ + +/* Anti-Pop WAIT Stage Timing Control Register */ +#define ICDC_APWAIT_WAITSN_BIT 0 +#define ICDC_APWAIT_WAITSN_MASK (0x7ff << ICDC_APWAIT_WAITSN_BIT) + +/* Anti-Pop HPEN-PRE Stage Timing Control Register */ +#define ICDC_APPRE_PRESN_BIT 0 +#define ICDC_APPRE_PRESN_MASK (0x1ff << ICDC_APPRE_PRESN_BIT) + +/* Anti-Pop HPEN Stage Timing Control Register */ +#define ICDC_APHPEN_HPENSN_BIT 0 +#define ICDC_APHPEN_HPENSN_MASK (0x3fff << ICDC_APHPEN_HPENSN_BIT) + +/* Anti-Pop Status Register */ +#define ICDC_SR_HPST_BIT 14 /* Headphone Amplifier State */ +#define ICDC_SR_HPST_MASK (0x7 << ICDC_SR_HPST_BIT) +#define ICDC_SR_HPST_HP_OFF (0x0 << ICDC_SR_HPST_BIT) /* HP amplifier is off */ +#define ICDC_SR_HPST_TON_WAIT (0x1 << ICDC_SR_HPST_BIT) /* wait state in turn-on */ + #define ICDC_SR_HPST_TON_PRE (0x2 << ICDC_SR_HPST_BIT) /* pre-enable state in turn-on */ +#define ICDC_SR_HPST_TON_HPEN (0x3 << ICDC_SR_HPST_BIT) /* HP enable state in turn-on */ + #define ICDC_SR_HPST_TOFF_HPEN (0x4 << ICDC_SR_HPST_BIT) /* HP enable state in turn-off */ + #define ICDC_SR_HPST_TOFF_PRE (0x5 << ICDC_SR_HPST_BIT) /* pre-enable state in turn-off */ + #define ICDC_SR_HPST_TOFF_WAIT (0x6 << ICDC_SR_HPST_BIT) /* wait state in turn-off */ + #define ICDC_SR_HPST_HP_ON (0x7 << ICDC_SR_HPST_BIT) /* HP amplifier is on */ +#define ICDC_SR_SNCNT_BIT 0 /* Sample Number Counter */ +#define ICDC_SR_SNCNT_MASK (0x3fff << ICDC_SR_SNCNT_BIT) + + +/************************************************************************* + * I2C + *************************************************************************/ +#define I2C_DR (I2C_BASE + 0x000) +#define I2C_CR (I2C_BASE + 0x004) +#define I2C_SR (I2C_BASE + 0x008) +#define I2C_GR (I2C_BASE + 0x00C) + +#define REG_I2C_DR REG8(I2C_DR) +#define REG_I2C_CR REG8(I2C_CR) +#define REG_I2C_SR REG8(I2C_SR) +#define REG_I2C_GR REG16(I2C_GR) + +/* I2C Control Register (I2C_CR) */ + +#define I2C_CR_IEN (1 << 4) +#define I2C_CR_STA (1 << 3) +#define I2C_CR_STO (1 << 2) +#define I2C_CR_AC (1 << 1) +#define I2C_CR_I2CE (1 << 0) + +/* I2C Status Register (I2C_SR) */ + +#define I2C_SR_STX (1 << 4) +#define I2C_SR_BUSY (1 << 3) +#define I2C_SR_TEND (1 << 2) +#define I2C_SR_DRF (1 << 1) +#define I2C_SR_ACKF (1 << 0) + + +/************************************************************************* + * SSI + *************************************************************************/ +#define SSI_DR (SSI_BASE + 0x000) +#define SSI_CR0 (SSI_BASE + 0x004) +#define SSI_CR1 (SSI_BASE + 0x008) +#define SSI_SR (SSI_BASE + 0x00C) +#define SSI_ITR (SSI_BASE + 0x010) +#define SSI_ICR (SSI_BASE + 0x014) +#define SSI_GR (SSI_BASE + 0x018) + +#define REG_SSI_DR REG32(SSI_DR) +#define REG_SSI_CR0 REG16(SSI_CR0) +#define REG_SSI_CR1 REG32(SSI_CR1) +#define REG_SSI_SR REG32(SSI_SR) +#define REG_SSI_ITR REG16(SSI_ITR) +#define REG_SSI_ICR REG8(SSI_ICR) +#define REG_SSI_GR REG16(SSI_GR) + +/* SSI Data Register (SSI_DR) */ + +#define SSI_DR_GPC_BIT 0 +#define SSI_DR_GPC_MASK (0x1ff << SSI_DR_GPC_BIT) + +/* SSI Control Register 0 (SSI_CR0) */ + +#define SSI_CR0_SSIE (1 << 15) +#define SSI_CR0_TIE (1 << 14) +#define SSI_CR0_RIE (1 << 13) +#define SSI_CR0_TEIE (1 << 12) +#define SSI_CR0_REIE (1 << 11) +#define SSI_CR0_LOOP (1 << 10) +#define SSI_CR0_RFINE (1 << 9) +#define SSI_CR0_RFINC (1 << 8) +#define SSI_CR0_FSEL (1 << 6) +#define SSI_CR0_TFLUSH (1 << 2) +#define SSI_CR0_RFLUSH (1 << 1) +#define SSI_CR0_DISREV (1 << 0) + +/* SSI Control Register 1 (SSI_CR1) */ + +#define SSI_CR1_FRMHL_BIT 30 +#define SSI_CR1_FRMHL_MASK (0x3 << SSI_CR1_FRMHL_BIT) + #define SSI_CR1_FRMHL_CELOW_CE2LOW (0 << SSI_CR1_FRMHL_BIT) /* SSI_CE_ is low valid and SSI_CE2_ is low valid */ + #define SSI_CR1_FRMHL_CEHIGH_CE2LOW (1 << SSI_CR1_FRMHL_BIT) /* SSI_CE_ is high valid and SSI_CE2_ is low valid */ + #define SSI_CR1_FRMHL_CELOW_CE2HIGH (2 << SSI_CR1_FRMHL_BIT) /* SSI_CE_ is low valid and SSI_CE2_ is high valid */ + #define SSI_CR1_FRMHL_CEHIGH_CE2HIGH (3 << SSI_CR1_FRMHL_BIT) /* SSI_CE_ is high valid and SSI_CE2_ is high valid */ +#define SSI_CR1_TFVCK_BIT 28 +#define SSI_CR1_TFVCK_MASK (0x3 << SSI_CR1_TFVCK_BIT) + #define SSI_CR1_TFVCK_0 (0 << SSI_CR1_TFVCK_BIT) + #define SSI_CR1_TFVCK_1 (1 << SSI_CR1_TFVCK_BIT) + #define SSI_CR1_TFVCK_2 (2 << SSI_CR1_TFVCK_BIT) + #define SSI_CR1_TFVCK_3 (3 << SSI_CR1_TFVCK_BIT) +#define SSI_CR1_TCKFI_BIT 26 +#define SSI_CR1_TCKFI_MASK (0x3 << SSI_CR1_TCKFI_BIT) + #define SSI_CR1_TCKFI_0 (0 << SSI_CR1_TCKFI_BIT) + #define SSI_CR1_TCKFI_1 (1 << SSI_CR1_TCKFI_BIT) + #define SSI_CR1_TCKFI_2 (2 << SSI_CR1_TCKFI_BIT) + #define SSI_CR1_TCKFI_3 (3 << SSI_CR1_TCKFI_BIT) +#define SSI_CR1_LFST (1 << 25) +#define SSI_CR1_ITFRM (1 << 24) +#define SSI_CR1_UNFIN (1 << 23) +#define SSI_CR1_MULTS (1 << 22) +#define SSI_CR1_FMAT_BIT 20 +#define SSI_CR1_FMAT_MASK (0x3 << SSI_CR1_FMAT_BIT) + #define SSI_CR1_FMAT_SPI (0 << SSI_CR1_FMAT_BIT) /* Motorola¡¯s SPI format */ + #define SSI_CR1_FMAT_SSP (1 << SSI_CR1_FMAT_BIT) /* TI's SSP format */ + #define SSI_CR1_FMAT_MW1 (2 << SSI_CR1_FMAT_BIT) /* National Microwire 1 format */ + #define SSI_CR1_FMAT_MW2 (3 << SSI_CR1_FMAT_BIT) /* National Microwire 2 format */ +#define SSI_CR1_MCOM_BIT 12 +#define SSI_CR1_MCOM_MASK (0xf << SSI_CR1_MCOM_BIT) + #define SSI_CR1_MCOM_1BIT (0x0 << SSI_CR1_MCOM_BIT) /* 1-bit command selected */ + #define SSI_CR1_MCOM_2BIT (0x1 << SSI_CR1_MCOM_BIT) /* 2-bit command selected */ + #define SSI_CR1_MCOM_3BIT (0x2 << SSI_CR1_MCOM_BIT) /* 3-bit command selected */ + #define SSI_CR1_MCOM_4BIT (0x3 << SSI_CR1_MCOM_BIT) /* 4-bit command selected */ + #define SSI_CR1_MCOM_5BIT (0x4 << SSI_CR1_MCOM_BIT) /* 5-bit command selected */ + #define SSI_CR1_MCOM_6BIT (0x5 << SSI_CR1_MCOM_BIT) /* 6-bit command selected */ + #define SSI_CR1_MCOM_7BIT (0x6 << SSI_CR1_MCOM_BIT) /* 7-bit command selected */ + #define SSI_CR1_MCOM_8BIT (0x7 << SSI_CR1_MCOM_BIT) /* 8-bit command selected */ + #define SSI_CR1_MCOM_9BIT (0x8 << SSI_CR1_MCOM_BIT) /* 9-bit command selected */ + #define SSI_CR1_MCOM_10BIT (0x9 << SSI_CR1_MCOM_BIT) /* 10-bit command selected */ + #define SSI_CR1_MCOM_11BIT (0xA << SSI_CR1_MCOM_BIT) /* 11-bit command selected */ + #define SSI_CR1_MCOM_12BIT (0xB << SSI_CR1_MCOM_BIT) /* 12-bit command selected */ + #define SSI_CR1_MCOM_13BIT (0xC << SSI_CR1_MCOM_BIT) /* 13-bit command selected */ + #define SSI_CR1_MCOM_14BIT (0xD << SSI_CR1_MCOM_BIT) /* 14-bit command selected */ + #define SSI_CR1_MCOM_15BIT (0xE << SSI_CR1_MCOM_BIT) /* 15-bit command selected */ + #define SSI_CR1_MCOM_16BIT (0xF << SSI_CR1_MCOM_BIT) /* 16-bit command selected */ +#define SSI_CR1_TTRG_BIT 10 +#define SSI_CR1_TTRG_MASK (0x3 << SSI_CR1_TTRG_BIT) + #define SSI_CR1_TTRG_1 (0 << SSI_CR1_TTRG_BIT)/* Less than or equal to 1 */ + #define SSI_CR1_TTRG_4 (1 << SSI_CR1_TTRG_BIT) /* Less than or equal to 4 */ + #define SSI_CR1_TTRG_8 (2 << SSI_CR1_TTRG_BIT) /* Less than or equal to 8 */ + #define SSI_CR1_TTRG_14 (3 << SSI_CR1_TTRG_BIT) /* Less than or equal to 14 */ +#define SSI_CR1_RTRG_BIT 8 +#define SSI_CR1_RTRG_MASK (0x3 << SSI_CR1_RTRG_BIT) + #define SSI_CR1_RTRG_1 (0 << SSI_CR1_RTRG_BIT) /* More than or equal to 1 */ + #define SSI_CR1_RTRG_4 (1 << SSI_CR1_RTRG_BIT) /* More than or equal to 4 */ + #define SSI_CR1_RTRG_8 (2 << SSI_CR1_RTRG_BIT) /* More than or equal to 8 */ + #define SSI_CR1_RTRG_14 (3 << SSI_CR1_RTRG_BIT) /* More than or equal to 14 */ +#define SSI_CR1_FLEN_BIT 4 +#define SSI_CR1_FLEN_MASK (0xf << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_2BIT (0x0 << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_3BIT (0x1 << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_4BIT (0x2 << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_5BIT (0x3 << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_6BIT (0x4 << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_7BIT (0x5 << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_8BIT (0x6 << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_9BIT (0x7 << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_10BIT (0x8 << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_11BIT (0x9 << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_12BIT (0xA << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_13BIT (0xB << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_14BIT (0xC << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_15BIT (0xD << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_16BIT (0xE << SSI_CR1_FLEN_BIT) + #define SSI_CR1_FLEN_17BIT (0xF << SSI_CR1_FLEN_BIT) +#define SSI_CR1_PHA (1 << 1) +#define SSI_CR1_POL (1 << 0) + +/* SSI Status Register (SSI_SR) */ + +#define SSI_SR_TFIFONUM_BIT 13 +#define SSI_SR_TFIFONUM_MASK (0x1f << SSI_SR_TFIFONUM_BIT) +#define SSI_SR_RFIFONUM_BIT 8 +#define SSI_SR_RFIFONUM_MASK (0x1f << SSI_SR_RFIFONUM_BIT) +#define SSI_SR_END (1 << 7) +#define SSI_SR_BUSY (1 << 6) +#define SSI_SR_TFF (1 << 5) +#define SSI_SR_RFE (1 << 4) +#define SSI_SR_TFHE (1 << 3) +#define SSI_SR_RFHF (1 << 2) +#define SSI_SR_UNDR (1 << 1) +#define SSI_SR_OVER (1 << 0) + +/* SSI Interval Time Control Register (SSI_ITR) */ + +#define SSI_ITR_CNTCLK (1 << 15) +#define SSI_ITR_IVLTM_BIT 0 +#define SSI_ITR_IVLTM_MASK (0x7fff << SSI_ITR_IVLTM_BIT) + + +/************************************************************************* + * MSC + *************************************************************************/ +#define MSC_STRPCL (MSC_BASE + 0x000) +#define MSC_STAT (MSC_BASE + 0x004) +#define MSC_CLKRT (MSC_BASE + 0x008) +#define MSC_CMDAT (MSC_BASE + 0x00C) +#define MSC_RESTO (MSC_BASE + 0x010) +#define MSC_RDTO (MSC_BASE + 0x014) +#define MSC_BLKLEN (MSC_BASE + 0x018) +#define MSC_NOB (MSC_BASE + 0x01C) +#define MSC_SNOB (MSC_BASE + 0x020) +#define MSC_IMASK (MSC_BASE + 0x024) +#define MSC_IREG (MSC_BASE + 0x028) +#define MSC_CMD (MSC_BASE + 0x02C) +#define MSC_ARG (MSC_BASE + 0x030) +#define MSC_RES (MSC_BASE + 0x034) +#define MSC_RXFIFO (MSC_BASE + 0x038) +#define MSC_TXFIFO (MSC_BASE + 0x03C) + +#define REG_MSC_STRPCL REG16(MSC_STRPCL) +#define REG_MSC_STAT REG32(MSC_STAT) +#define REG_MSC_CLKRT REG16(MSC_CLKRT) +#define REG_MSC_CMDAT REG32(MSC_CMDAT) +#define REG_MSC_RESTO REG16(MSC_RESTO) +#define REG_MSC_RDTO REG16(MSC_RDTO) +#define REG_MSC_BLKLEN REG16(MSC_BLKLEN) +#define REG_MSC_NOB REG16(MSC_NOB) +#define REG_MSC_SNOB REG16(MSC_SNOB) +#define REG_MSC_IMASK REG16(MSC_IMASK) +#define REG_MSC_IREG REG16(MSC_IREG) +#define REG_MSC_CMD REG8(MSC_CMD) +#define REG_MSC_ARG REG32(MSC_ARG) +#define REG_MSC_RES REG16(MSC_RES) +#define REG_MSC_RXFIFO REG32(MSC_RXFIFO) +#define REG_MSC_TXFIFO REG32(MSC_TXFIFO) + +/* MSC Clock and Control Register (MSC_STRPCL) */ + +#define MSC_STRPCL_EXIT_MULTIPLE (1 << 7) +#define MSC_STRPCL_EXIT_TRANSFER (1 << 6) +#define MSC_STRPCL_START_READWAIT (1 << 5) +#define MSC_STRPCL_STOP_READWAIT (1 << 4) +#define MSC_STRPCL_RESET (1 << 3) +#define MSC_STRPCL_START_OP (1 << 2) +#define MSC_STRPCL_CLOCK_CONTROL_BIT 0 +#define MSC_STRPCL_CLOCK_CONTROL_MASK (0x3 << MSC_STRPCL_CLOCK_CONTROL_BIT) + #define MSC_STRPCL_CLOCK_CONTROL_STOP (0x1 << MSC_STRPCL_CLOCK_CONTROL_BIT) /* Stop MMC/SD clock */ + #define MSC_STRPCL_CLOCK_CONTROL_START (0x2 << MSC_STRPCL_CLOCK_CONTROL_BIT) /* Start MMC/SD clock */ + +/* MSC Status Register (MSC_STAT) */ + +#define MSC_STAT_IS_RESETTING (1 << 15) +#define MSC_STAT_SDIO_INT_ACTIVE (1 << 14) +#define MSC_STAT_PRG_DONE (1 << 13) +#define MSC_STAT_DATA_TRAN_DONE (1 << 12) +#define MSC_STAT_END_CMD_RES (1 << 11) +#define MSC_STAT_DATA_FIFO_AFULL (1 << 10) +#define MSC_STAT_IS_READWAIT (1 << 9) +#define MSC_STAT_CLK_EN (1 << 8) +#define MSC_STAT_DATA_FIFO_FULL (1 << 7) +#define MSC_STAT_DATA_FIFO_EMPTY (1 << 6) +#define MSC_STAT_CRC_RES_ERR (1 << 5) +#define MSC_STAT_CRC_READ_ERROR (1 << 4) +#define MSC_STAT_CRC_WRITE_ERROR_BIT 2 +#define MSC_STAT_CRC_WRITE_ERROR_MASK (0x3 << MSC_STAT_CRC_WRITE_ERROR_BIT) + #define MSC_STAT_CRC_WRITE_ERROR_NO (0 << MSC_STAT_CRC_WRITE_ERROR_BIT) /* No error on transmission of data */ + #define MSC_STAT_CRC_WRITE_ERROR (1 << MSC_STAT_CRC_WRITE_ERROR_BIT) /* Card observed erroneous transmission of data */ + #define MSC_STAT_CRC_WRITE_ERROR_NOSTS (2 << MSC_STAT_CRC_WRITE_ERROR_BIT) /* No CRC status is sent back */ +#define MSC_STAT_TIME_OUT_RES (1 << 1) +#define MSC_STAT_TIME_OUT_READ (1 << 0) + +/* MSC Bus Clock Control Register (MSC_CLKRT) */ + +#define MSC_CLKRT_CLK_RATE_BIT 0 +#define MSC_CLKRT_CLK_RATE_MASK (0x7 << MSC_CLKRT_CLK_RATE_BIT) + #define MSC_CLKRT_CLK_RATE_DIV_1 (0x0 << MSC_CLKRT_CLK_RATE_BIT) /* CLK_SRC */ + #define MSC_CLKRT_CLK_RATE_DIV_2 (0x1 << MSC_CLKRT_CLK_RATE_BIT) /* 1/2 of CLK_SRC */ + #define MSC_CLKRT_CLK_RATE_DIV_4 (0x2 << MSC_CLKRT_CLK_RATE_BIT) /* 1/4 of CLK_SRC */ + #define MSC_CLKRT_CLK_RATE_DIV_8 (0x3 << MSC_CLKRT_CLK_RATE_BIT) /* 1/8 of CLK_SRC */ + #define MSC_CLKRT_CLK_RATE_DIV_16 (0x4 << MSC_CLKRT_CLK_RATE_BIT) /* 1/16 of CLK_SRC */ + #define MSC_CLKRT_CLK_RATE_DIV_32 (0x5 << MSC_CLKRT_CLK_RATE_BIT) /* 1/32 of CLK_SRC */ + #define MSC_CLKRT_CLK_RATE_DIV_64 (0x6 << MSC_CLKRT_CLK_RATE_BIT) /* 1/64 of CLK_SRC */ + #define MSC_CLKRT_CLK_RATE_DIV_128 (0x7 << MSC_CLKRT_CLK_RATE_BIT) /* 1/128 of CLK_SRC */ + +/* MSC Command Sequence Control Register (MSC_CMDAT) */ + +#define MSC_CMDAT_IO_ABORT (1 << 11) +#define MSC_CMDAT_BUS_WIDTH_BIT 9 +#define MSC_CMDAT_BUS_WIDTH_MASK (0x3 << MSC_CMDAT_BUS_WIDTH_BIT) + #define MSC_CMDAT_BUS_WIDTH_1BIT (0x0 << MSC_CMDAT_BUS_WIDTH_BIT) /* 1-bit data bus */ + #define MSC_CMDAT_BUS_WIDTH_4BIT (0x2 << MSC_CMDAT_BUS_WIDTH_BIT) /* 4-bit data bus */ + #define CMDAT_BUS_WIDTH1 (0x0 << MSC_CMDAT_BUS_WIDTH_BIT) + #define CMDAT_BUS_WIDTH4 (0x2 << MSC_CMDAT_BUS_WIDTH_BIT) +#define MSC_CMDAT_DMA_EN (1 << 8) +#define MSC_CMDAT_INIT (1 << 7) +#define MSC_CMDAT_BUSY (1 << 6) +#define MSC_CMDAT_STREAM_BLOCK (1 << 5) +#define MSC_CMDAT_WRITE (1 << 4) +#define MSC_CMDAT_READ (0 << 4) +#define MSC_CMDAT_DATA_EN (1 << 3) +#define MSC_CMDAT_RESPONSE_BIT 0 +#define MSC_CMDAT_RESPONSE_MASK (0x7 << MSC_CMDAT_RESPONSE_BIT) + #define MSC_CMDAT_RESPONSE_NONE (0x0 << MSC_CMDAT_RESPONSE_BIT) /* No response */ + #define MSC_CMDAT_RESPONSE_R1 (0x1 << MSC_CMDAT_RESPONSE_BIT) /* Format R1 and R1b */ + #define MSC_CMDAT_RESPONSE_R2 (0x2 << MSC_CMDAT_RESPONSE_BIT) /* Format R2 */ + #define MSC_CMDAT_RESPONSE_R3 (0x3 << MSC_CMDAT_RESPONSE_BIT) /* Format R3 */ + #define MSC_CMDAT_RESPONSE_R4 (0x4 << MSC_CMDAT_RESPONSE_BIT) /* Format R4 */ + #define MSC_CMDAT_RESPONSE_R5 (0x5 << MSC_CMDAT_RESPONSE_BIT) /* Format R5 */ + #define MSC_CMDAT_RESPONSE_R6 (0x6 << MSC_CMDAT_RESPONSE_BIT) /* Format R6 */ + +#define CMDAT_DMA_EN (1 << 8) +#define CMDAT_INIT (1 << 7) +#define CMDAT_BUSY (1 << 6) +#define CMDAT_STREAM (1 << 5) +#define CMDAT_WRITE (1 << 4) +#define CMDAT_DATA_EN (1 << 3) + +/* MSC Interrupts Mask Register (MSC_IMASK) */ + +#define MSC_IMASK_SDIO (1 << 7) +#define MSC_IMASK_TXFIFO_WR_REQ (1 << 6) +#define MSC_IMASK_RXFIFO_RD_REQ (1 << 5) +#define MSC_IMASK_END_CMD_RES (1 << 2) +#define MSC_IMASK_PRG_DONE (1 << 1) +#define MSC_IMASK_DATA_TRAN_DONE (1 << 0) + + +/* MSC Interrupts Status Register (MSC_IREG) */ + +#define MSC_IREG_SDIO (1 << 7) +#define MSC_IREG_TXFIFO_WR_REQ (1 << 6) +#define MSC_IREG_RXFIFO_RD_REQ (1 << 5) +#define MSC_IREG_END_CMD_RES (1 << 2) +#define MSC_IREG_PRG_DONE (1 << 1) +#define MSC_IREG_DATA_TRAN_DONE (1 << 0) + + +/************************************************************************* + * EMC (External Memory Controller) + *************************************************************************/ +#define EMC_BCR (EMC_BASE + 0x10) /* BCR */ + +#define EMC_SMCR0 (EMC_BASE + 0x10) /* Static Memory Control Register 0 */ +#define EMC_SMCR1 (EMC_BASE + 0x14) /* Static Memory Control Register 1 */ +#define EMC_SMCR2 (EMC_BASE + 0x18) /* Static Memory Control Register 2 */ +#define EMC_SMCR3 (EMC_BASE + 0x1c) /* Static Memory Control Register 3 */ +#define EMC_SMCR4 (EMC_BASE + 0x20) /* Static Memory Control Register 4 */ +#define EMC_SACR0 (EMC_BASE + 0x30) /* Static Memory Bank 0 Addr Config Reg */ +#define EMC_SACR1 (EMC_BASE + 0x34) /* Static Memory Bank 1 Addr Config Reg */ +#define EMC_SACR2 (EMC_BASE + 0x38) /* Static Memory Bank 2 Addr Config Reg */ +#define EMC_SACR3 (EMC_BASE + 0x3c) /* Static Memory Bank 3 Addr Config Reg */ +#define EMC_SACR4 (EMC_BASE + 0x40) /* Static Memory Bank 4 Addr Config Reg */ + +#define EMC_NFCSR (EMC_BASE + 0x050) /* NAND Flash Control/Status Register */ +#define EMC_NFECR (EMC_BASE + 0x100) /* NAND Flash ECC Control Register */ +#define EMC_NFECC (EMC_BASE + 0x104) /* NAND Flash ECC Data Register */ +#define EMC_NFPAR0 (EMC_BASE + 0x108) /* NAND Flash RS Parity 0 Register */ +#define EMC_NFPAR1 (EMC_BASE + 0x10c) /* NAND Flash RS Parity 1 Register */ +#define EMC_NFPAR2 (EMC_BASE + 0x110) /* NAND Flash RS Parity 2 Register */ +#define EMC_NFINTS (EMC_BASE + 0x114) /* NAND Flash Interrupt Status Register */ +#define EMC_NFINTE (EMC_BASE + 0x118) /* NAND Flash Interrupt Enable Register */ +#define EMC_NFERR0 (EMC_BASE + 0x11c) /* NAND Flash RS Error Report 0 Register */ +#define EMC_NFERR1 (EMC_BASE + 0x120) /* NAND Flash RS Error Report 1 Register */ +#define EMC_NFERR2 (EMC_BASE + 0x124) /* NAND Flash RS Error Report 2 Register */ +#define EMC_NFERR3 (EMC_BASE + 0x128) /* NAND Flash RS Error Report 3 Register */ + +#define EMC_DMCR (EMC_BASE + 0x80) /* DRAM Control Register */ +#define EMC_RTCSR (EMC_BASE + 0x84) /* Refresh Time Control/Status Register */ +#define EMC_RTCNT (EMC_BASE + 0x88) /* Refresh Timer Counter */ +#define EMC_RTCOR (EMC_BASE + 0x8c) /* Refresh Time Constant Register */ +#define EMC_DMAR0 (EMC_BASE + 0x90) /* SDRAM Bank 0 Addr Config Register */ +#define EMC_SDMR0 (EMC_BASE + 0xa000) /* Mode Register of SDRAM bank 0 */ + +#define REG_EMC_BCR REG32(EMC_BCR) + +#define REG_EMC_SMCR0 REG32(EMC_SMCR0) +#define REG_EMC_SMCR1 REG32(EMC_SMCR1) +#define REG_EMC_SMCR2 REG32(EMC_SMCR2) +#define REG_EMC_SMCR3 REG32(EMC_SMCR3) +#define REG_EMC_SMCR4 REG32(EMC_SMCR4) +#define REG_EMC_SACR0 REG32(EMC_SACR0) +#define REG_EMC_SACR1 REG32(EMC_SACR1) +#define REG_EMC_SACR2 REG32(EMC_SACR2) +#define REG_EMC_SACR3 REG32(EMC_SACR3) +#define REG_EMC_SACR4 REG32(EMC_SACR4) + +#define REG_EMC_NFCSR REG32(EMC_NFCSR) +#define REG_EMC_NFECR REG32(EMC_NFECR) +#define REG_EMC_NFECC REG32(EMC_NFECC) +#define REG_EMC_NFPAR0 REG32(EMC_NFPAR0) +#define REG_EMC_NFPAR1 REG32(EMC_NFPAR1) +#define REG_EMC_NFPAR2 REG32(EMC_NFPAR2) +#define REG_EMC_NFINTS REG32(EMC_NFINTS) +#define REG_EMC_NFINTE REG32(EMC_NFINTE) +#define REG_EMC_NFERR0 REG32(EMC_NFERR0) +#define REG_EMC_NFERR1 REG32(EMC_NFERR1) +#define REG_EMC_NFERR2 REG32(EMC_NFERR2) +#define REG_EMC_NFERR3 REG32(EMC_NFERR3) + +#define REG_EMC_DMCR REG32(EMC_DMCR) +#define REG_EMC_RTCSR REG16(EMC_RTCSR) +#define REG_EMC_RTCNT REG16(EMC_RTCNT) +#define REG_EMC_RTCOR REG16(EMC_RTCOR) +#define REG_EMC_DMAR0 REG32(EMC_DMAR0) + +/* Static Memory Control Register */ +#define EMC_SMCR_STRV_BIT 24 +#define EMC_SMCR_STRV_MASK (0x0f << EMC_SMCR_STRV_BIT) +#define EMC_SMCR_TAW_BIT 20 +#define EMC_SMCR_TAW_MASK (0x0f << EMC_SMCR_TAW_BIT) +#define EMC_SMCR_TBP_BIT 16 +#define EMC_SMCR_TBP_MASK (0x0f << EMC_SMCR_TBP_BIT) +#define EMC_SMCR_TAH_BIT 12 +#define EMC_SMCR_TAH_MASK (0x07 << EMC_SMCR_TAH_BIT) +#define EMC_SMCR_TAS_BIT 8 +#define EMC_SMCR_TAS_MASK (0x07 << EMC_SMCR_TAS_BIT) +#define EMC_SMCR_BW_BIT 6 +#define EMC_SMCR_BW_MASK (0x03 << EMC_SMCR_BW_BIT) + #define EMC_SMCR_BW_8BIT (0 << EMC_SMCR_BW_BIT) + #define EMC_SMCR_BW_16BIT (1 << EMC_SMCR_BW_BIT) + #define EMC_SMCR_BW_32BIT (2 << EMC_SMCR_BW_BIT) +#define EMC_SMCR_BCM (1 << 3) +#define EMC_SMCR_BL_BIT 1 +#define EMC_SMCR_BL_MASK (0x03 << EMC_SMCR_BL_BIT) + #define EMC_SMCR_BL_4 (0 << EMC_SMCR_BL_BIT) + #define EMC_SMCR_BL_8 (1 << EMC_SMCR_BL_BIT) + #define EMC_SMCR_BL_16 (2 << EMC_SMCR_BL_BIT) + #define EMC_SMCR_BL_32 (3 << EMC_SMCR_BL_BIT) +#define EMC_SMCR_SMT (1 << 0) + +/* Static Memory Bank Addr Config Reg */ +#define EMC_SACR_BASE_BIT 8 +#define EMC_SACR_BASE_MASK (0xff << EMC_SACR_BASE_BIT) +#define EMC_SACR_MASK_BIT 0 +#define EMC_SACR_MASK_MASK (0xff << EMC_SACR_MASK_BIT) + +/* NAND Flash Control/Status Register */ +#define EMC_NFCSR_NFCE4 (1 << 7) /* NAND Flash Enable */ +#define EMC_NFCSR_NFE4 (1 << 6) /* NAND Flash FCE# Assertion Enable */ +#define EMC_NFCSR_NFCE3 (1 << 5) +#define EMC_NFCSR_NFE3 (1 << 4) +#define EMC_NFCSR_NFCE2 (1 << 3) +#define EMC_NFCSR_NFE2 (1 << 2) +#define EMC_NFCSR_NFCE1 (1 << 1) +#define EMC_NFCSR_NFE1 (1 << 0) + +/* NAND Flash ECC Control Register */ +#define EMC_NFECR_PRDY (1 << 4) /* Parity Ready */ +#define EMC_NFECR_RS_DECODING (0 << 3) /* RS is in decoding phase */ +#define EMC_NFECR_RS_ENCODING (1 << 3) /* RS is in encoding phase */ +#define EMC_NFECR_HAMMING (0 << 2) /* Select HAMMING Correction Algorithm */ +#define EMC_NFECR_RS (1 << 2) /* Select RS Correction Algorithm */ +#define EMC_NFECR_ERST (1 << 1) /* ECC Reset */ +#define EMC_NFECR_ECCE (1 << 0) /* ECC Enable */ + +/* NAND Flash ECC Data Register */ +#define EMC_NFECC_ECC2_BIT 16 +#define EMC_NFECC_ECC2_MASK (0xff << EMC_NFECC_ECC2_BIT) +#define EMC_NFECC_ECC1_BIT 8 +#define EMC_NFECC_ECC1_MASK (0xff << EMC_NFECC_ECC1_BIT) +#define EMC_NFECC_ECC0_BIT 0 +#define EMC_NFECC_ECC0_MASK (0xff << EMC_NFECC_ECC0_BIT) + +/* NAND Flash Interrupt Status Register */ +#define EMC_NFINTS_ERRCNT_BIT 29 /* Error Count */ +#define EMC_NFINTS_ERRCNT_MASK (0x7 << EMC_NFINTS_ERRCNT_BIT) +#define EMC_NFINTS_PADF (1 << 4) /* Padding Finished */ +#define EMC_NFINTS_DECF (1 << 3) /* Decoding Finished */ +#define EMC_NFINTS_ENCF (1 << 2) /* Encoding Finished */ +#define EMC_NFINTS_UNCOR (1 << 1) /* Uncorrectable Error Occurred */ +#define EMC_NFINTS_ERR (1 << 0) /* Error Occurred */ + +/* NAND Flash Interrupt Enable Register */ +#define EMC_NFINTE_PADFE (1 << 4) /* Padding Finished Interrupt Enable */ +#define EMC_NFINTE_DECFE (1 << 3) /* Decoding Finished Interrupt Enable */ +#define EMC_NFINTE_ENCFE (1 << 2) /* Encoding Finished Interrupt Enable */ +#define EMC_NFINTE_UNCORE (1 << 1) /* Uncorrectable Error Occurred Intr Enable */ +#define EMC_NFINTE_ERRE (1 << 0) /* Error Occurred Interrupt */ + +/* NAND Flash RS Error Report Register */ +#define EMC_NFERR_INDEX_BIT 16 /* Error Symbol Index */ +#define EMC_NFERR_INDEX_MASK (0x1ff << EMC_NFERR_INDEX_BIT) +#define EMC_NFERR_MASK_BIT 0 /* Error Symbol Value */ +#define EMC_NFERR_MASK_MASK (0x1ff << EMC_NFERR_MASK_BIT) + + +/* DRAM Control Register */ +#define EMC_DMCR_BW_BIT 31 +#define EMC_DMCR_BW (1 << EMC_DMCR_BW_BIT) +#define EMC_DMCR_CA_BIT 26 +#define EMC_DMCR_CA_MASK (0x07 << EMC_DMCR_CA_BIT) + #define EMC_DMCR_CA_8 (0 << EMC_DMCR_CA_BIT) + #define EMC_DMCR_CA_9 (1 << EMC_DMCR_CA_BIT) + #define EMC_DMCR_CA_10 (2 << EMC_DMCR_CA_BIT) + #define EMC_DMCR_CA_11 (3 << EMC_DMCR_CA_BIT) + #define EMC_DMCR_CA_12 (4 << EMC_DMCR_CA_BIT) +#define EMC_DMCR_RMODE (1 << 25) +#define EMC_DMCR_RFSH (1 << 24) +#define EMC_DMCR_MRSET (1 << 23) +#define EMC_DMCR_RA_BIT 20 +#define EMC_DMCR_RA_MASK (0x03 << EMC_DMCR_RA_BIT) + #define EMC_DMCR_RA_11 (0 << EMC_DMCR_RA_BIT) + #define EMC_DMCR_RA_12 (1 << EMC_DMCR_RA_BIT) + #define EMC_DMCR_RA_13 (2 << EMC_DMCR_RA_BIT) +#define EMC_DMCR_BA_BIT 19 +#define EMC_DMCR_BA (1 << EMC_DMCR_BA_BIT) +#define EMC_DMCR_PDM (1 << 18) +#define EMC_DMCR_EPIN (1 << 17) +#define EMC_DMCR_TRAS_BIT 13 +#define EMC_DMCR_TRAS_MASK (0x07 << EMC_DMCR_TRAS_BIT) +#define EMC_DMCR_RCD_BIT 11 +#define EMC_DMCR_RCD_MASK (0x03 << EMC_DMCR_RCD_BIT) +#define EMC_DMCR_TPC_BIT 8 +#define EMC_DMCR_TPC_MASK (0x07 << EMC_DMCR_TPC_BIT) +#define EMC_DMCR_TRWL_BIT 5 +#define EMC_DMCR_TRWL_MASK (0x03 << EMC_DMCR_TRWL_BIT) +#define EMC_DMCR_TRC_BIT 2 +#define EMC_DMCR_TRC_MASK (0x07 << EMC_DMCR_TRC_BIT) +#define EMC_DMCR_TCL_BIT 0 +#define EMC_DMCR_TCL_MASK (0x03 << EMC_DMCR_TCL_BIT) + +/* Refresh Time Control/Status Register */ +#define EMC_RTCSR_CMF (1 << 7) +#define EMC_RTCSR_CKS_BIT 0 +#define EMC_RTCSR_CKS_MASK (0x07 << EMC_RTCSR_CKS_BIT) + #define EMC_RTCSR_CKS_DISABLE (0 << EMC_RTCSR_CKS_BIT) + #define EMC_RTCSR_CKS_4 (1 << EMC_RTCSR_CKS_BIT) + #define EMC_RTCSR_CKS_16 (2 << EMC_RTCSR_CKS_BIT) + #define EMC_RTCSR_CKS_64 (3 << EMC_RTCSR_CKS_BIT) + #define EMC_RTCSR_CKS_256 (4 << EMC_RTCSR_CKS_BIT) + #define EMC_RTCSR_CKS_1024 (5 << EMC_RTCSR_CKS_BIT) + #define EMC_RTCSR_CKS_2048 (6 << EMC_RTCSR_CKS_BIT) + #define EMC_RTCSR_CKS_4096 (7 << EMC_RTCSR_CKS_BIT) + +/* SDRAM Bank Address Configuration Register */ +#define EMC_DMAR_BASE_BIT 8 +#define EMC_DMAR_BASE_MASK (0xff << EMC_DMAR_BASE_BIT) +#define EMC_DMAR_MASK_BIT 0 +#define EMC_DMAR_MASK_MASK (0xff << EMC_DMAR_MASK_BIT) + +/* Mode Register of SDRAM bank 0 */ +#define EMC_SDMR_BM (1 << 9) /* Write Burst Mode */ +#define EMC_SDMR_OM_BIT 7 /* Operating Mode */ +#define EMC_SDMR_OM_MASK (3 << EMC_SDMR_OM_BIT) + #define EMC_SDMR_OM_NORMAL (0 << EMC_SDMR_OM_BIT) +#define EMC_SDMR_CAS_BIT 4 /* CAS Latency */ +#define EMC_SDMR_CAS_MASK (7 << EMC_SDMR_CAS_BIT) + #define EMC_SDMR_CAS_1 (1 << EMC_SDMR_CAS_BIT) + #define EMC_SDMR_CAS_2 (2 << EMC_SDMR_CAS_BIT) + #define EMC_SDMR_CAS_3 (3 << EMC_SDMR_CAS_BIT) +#define EMC_SDMR_BT_BIT 3 /* Burst Type */ +#define EMC_SDMR_BT_MASK (1 << EMC_SDMR_BT_BIT) + #define EMC_SDMR_BT_SEQ (0 << EMC_SDMR_BT_BIT) /* Sequential */ + #define EMC_SDMR_BT_INT (1 << EMC_SDMR_BT_BIT) /* Interleave */ +#define EMC_SDMR_BL_BIT 0 /* Burst Length */ +#define EMC_SDMR_BL_MASK (7 << EMC_SDMR_BL_BIT) + #define EMC_SDMR_BL_1 (0 << EMC_SDMR_BL_BIT) + #define EMC_SDMR_BL_2 (1 << EMC_SDMR_BL_BIT) + #define EMC_SDMR_BL_4 (2 << EMC_SDMR_BL_BIT) + #define EMC_SDMR_BL_8 (3 << EMC_SDMR_BL_BIT) + +#define EMC_SDMR_CAS2_16BIT \ + (EMC_SDMR_CAS_2 | EMC_SDMR_BT_SEQ | EMC_SDMR_BL_2) +#define EMC_SDMR_CAS2_32BIT \ + (EMC_SDMR_CAS_2 | EMC_SDMR_BT_SEQ | EMC_SDMR_BL_4) +#define EMC_SDMR_CAS3_16BIT \ + (EMC_SDMR_CAS_3 | EMC_SDMR_BT_SEQ | EMC_SDMR_BL_2) +#define EMC_SDMR_CAS3_32BIT \ + (EMC_SDMR_CAS_3 | EMC_SDMR_BT_SEQ | EMC_SDMR_BL_4) + + +/************************************************************************* + * CIM + *************************************************************************/ +#define CIM_CFG (CIM_BASE + 0x0000) +#define CIM_CTRL (CIM_BASE + 0x0004) +#define CIM_STATE (CIM_BASE + 0x0008) +#define CIM_IID (CIM_BASE + 0x000C) +#define CIM_RXFIFO (CIM_BASE + 0x0010) +#define CIM_DA (CIM_BASE + 0x0020) +#define CIM_FA (CIM_BASE + 0x0024) +#define CIM_FID (CIM_BASE + 0x0028) +#define CIM_CMD (CIM_BASE + 0x002C) + +#define REG_CIM_CFG REG32(CIM_CFG) +#define REG_CIM_CTRL REG32(CIM_CTRL) +#define REG_CIM_STATE REG32(CIM_STATE) +#define REG_CIM_IID REG32(CIM_IID) +#define REG_CIM_RXFIFO REG32(CIM_RXFIFO) +#define REG_CIM_DA REG32(CIM_DA) +#define REG_CIM_FA REG32(CIM_FA) +#define REG_CIM_FID REG32(CIM_FID) +#define REG_CIM_CMD REG32(CIM_CMD) + +/* CIM Configuration Register (CIM_CFG) */ + +#define CIM_CFG_INV_DAT (1 << 15) +#define CIM_CFG_VSP (1 << 14) +#define CIM_CFG_HSP (1 << 13) +#define CIM_CFG_PCP (1 << 12) +#define CIM_CFG_DUMMY_ZERO (1 << 9) +#define CIM_CFG_EXT_VSYNC (1 << 8) +#define CIM_CFG_PACK_BIT 4 +#define CIM_CFG_PACK_MASK (0x7 << CIM_CFG_PACK_BIT) + #define CIM_CFG_PACK_0 (0 << CIM_CFG_PACK_BIT) + #define CIM_CFG_PACK_1 (1 << CIM_CFG_PACK_BIT) + #define CIM_CFG_PACK_2 (2 << CIM_CFG_PACK_BIT) + #define CIM_CFG_PACK_3 (3 << CIM_CFG_PACK_BIT) + #define CIM_CFG_PACK_4 (4 << CIM_CFG_PACK_BIT) + #define CIM_CFG_PACK_5 (5 << CIM_CFG_PACK_BIT) + #define CIM_CFG_PACK_6 (6 << CIM_CFG_PACK_BIT) + #define CIM_CFG_PACK_7 (7 << CIM_CFG_PACK_BIT) +#define CIM_CFG_DSM_BIT 0 +#define CIM_CFG_DSM_MASK (0x3 << CIM_CFG_DSM_BIT) + #define CIM_CFG_DSM_CPM (0 << CIM_CFG_DSM_BIT) /* CCIR656 Progressive Mode */ + #define CIM_CFG_DSM_CIM (1 << CIM_CFG_DSM_BIT) /* CCIR656 Interlace Mode */ + #define CIM_CFG_DSM_GCM (2 << CIM_CFG_DSM_BIT) /* Gated Clock Mode */ + #define CIM_CFG_DSM_NGCM (3 << CIM_CFG_DSM_BIT) /* Non-Gated Clock Mode */ + +/* CIM Control Register (CIM_CTRL) */ + +#define CIM_CTRL_MCLKDIV_BIT 24 +#define CIM_CTRL_MCLKDIV_MASK (0xff << CIM_CTRL_MCLKDIV_BIT) +#define CIM_CTRL_FRC_BIT 16 +#define CIM_CTRL_FRC_MASK (0xf << CIM_CTRL_FRC_BIT) + #define CIM_CTRL_FRC_1 (0x0 << CIM_CTRL_FRC_BIT) /* Sample every frame */ + #define CIM_CTRL_FRC_2 (0x1 << CIM_CTRL_FRC_BIT) /* Sample 1/2 frame */ + #define CIM_CTRL_FRC_3 (0x2 << CIM_CTRL_FRC_BIT) /* Sample 1/3 frame */ + #define CIM_CTRL_FRC_4 (0x3 << CIM_CTRL_FRC_BIT) /* Sample 1/4 frame */ + #define CIM_CTRL_FRC_5 (0x4 << CIM_CTRL_FRC_BIT) /* Sample 1/5 frame */ + #define CIM_CTRL_FRC_6 (0x5 << CIM_CTRL_FRC_BIT) /* Sample 1/6 frame */ + #define CIM_CTRL_FRC_7 (0x6 << CIM_CTRL_FRC_BIT) /* Sample 1/7 frame */ + #define CIM_CTRL_FRC_8 (0x7 << CIM_CTRL_FRC_BIT) /* Sample 1/8 frame */ + #define CIM_CTRL_FRC_9 (0x8 << CIM_CTRL_FRC_BIT) /* Sample 1/9 frame */ + #define CIM_CTRL_FRC_10 (0x9 << CIM_CTRL_FRC_BIT) /* Sample 1/10 frame */ + #define CIM_CTRL_FRC_11 (0xA << CIM_CTRL_FRC_BIT) /* Sample 1/11 frame */ + #define CIM_CTRL_FRC_12 (0xB << CIM_CTRL_FRC_BIT) /* Sample 1/12 frame */ + #define CIM_CTRL_FRC_13 (0xC << CIM_CTRL_FRC_BIT) /* Sample 1/13 frame */ + #define CIM_CTRL_FRC_14 (0xD << CIM_CTRL_FRC_BIT) /* Sample 1/14 frame */ + #define CIM_CTRL_FRC_15 (0xE << CIM_CTRL_FRC_BIT) /* Sample 1/15 frame */ + #define CIM_CTRL_FRC_16 (0xF << CIM_CTRL_FRC_BIT) /* Sample 1/16 frame */ +#define CIM_CTRL_VDDM (1 << 13) +#define CIM_CTRL_DMA_SOFM (1 << 12) +#define CIM_CTRL_DMA_EOFM (1 << 11) +#define CIM_CTRL_DMA_STOPM (1 << 10) +#define CIM_CTRL_RXF_TRIGM (1 << 9) +#define CIM_CTRL_RXF_OFM (1 << 8) +#define CIM_CTRL_RXF_TRIG_BIT 4 +#define CIM_CTRL_RXF_TRIG_MASK (0x7 << CIM_CTRL_RXF_TRIG_BIT) + #define CIM_CTRL_RXF_TRIG_4 (0 << CIM_CTRL_RXF_TRIG_BIT) /* RXFIFO Trigger Value is 4 */ + #define CIM_CTRL_RXF_TRIG_8 (1 << CIM_CTRL_RXF_TRIG_BIT) /* RXFIFO Trigger Value is 8 */ + #define CIM_CTRL_RXF_TRIG_12 (2 << CIM_CTRL_RXF_TRIG_BIT) /* RXFIFO Trigger Value is 12 */ + #define CIM_CTRL_RXF_TRIG_16 (3 << CIM_CTRL_RXF_TRIG_BIT) /* RXFIFO Trigger Value is 16 */ + #define CIM_CTRL_RXF_TRIG_20 (4 << CIM_CTRL_RXF_TRIG_BIT) /* RXFIFO Trigger Value is 20 */ + #define CIM_CTRL_RXF_TRIG_24 (5 << CIM_CTRL_RXF_TRIG_BIT) /* RXFIFO Trigger Value is 24 */ + #define CIM_CTRL_RXF_TRIG_28 (6 << CIM_CTRL_RXF_TRIG_BIT) /* RXFIFO Trigger Value is 28 */ + #define CIM_CTRL_RXF_TRIG_32 (7 << CIM_CTRL_RXF_TRIG_BIT) /* RXFIFO Trigger Value is 32 */ +#define CIM_CTRL_DMA_EN (1 << 2) +#define CIM_CTRL_RXF_RST (1 << 1) +#define CIM_CTRL_ENA (1 << 0) + +/* CIM State Register (CIM_STATE) */ + +#define CIM_STATE_DMA_SOF (1 << 6) +#define CIM_STATE_DMA_EOF (1 << 5) +#define CIM_STATE_DMA_STOP (1 << 4) +#define CIM_STATE_RXF_OF (1 << 3) +#define CIM_STATE_RXF_TRIG (1 << 2) +#define CIM_STATE_RXF_EMPTY (1 << 1) +#define CIM_STATE_VDD (1 << 0) + +/* CIM DMA Command Register (CIM_CMD) */ + +#define CIM_CMD_SOFINT (1 << 31) +#define CIM_CMD_EOFINT (1 << 30) +#define CIM_CMD_STOP (1 << 28) +#define CIM_CMD_LEN_BIT 0 +#define CIM_CMD_LEN_MASK (0xffffff << CIM_CMD_LEN_BIT) + + +/************************************************************************* + * SADC (Smart A/D Controller) + *************************************************************************/ + +#define SADC_ENA (SADC_BASE + 0x00) /* ADC Enable Register */ +#define SADC_CFG (SADC_BASE + 0x04) /* ADC Configure Register */ +#define SADC_CTRL (SADC_BASE + 0x08) /* ADC Control Register */ +#define SADC_STATE (SADC_BASE + 0x0C) /* ADC Status Register*/ +#define SADC_SAMETIME (SADC_BASE + 0x10) /* ADC Same Point Time Register */ +#define SADC_WAITTIME (SADC_BASE + 0x14) /* ADC Wait Time Register */ +#define SADC_TSDAT (SADC_BASE + 0x18) /* ADC Touch Screen Data Register */ +#define SADC_BATDAT (SADC_BASE + 0x1C) /* ADC PBAT Data Register */ +#define SADC_SADDAT (SADC_BASE + 0x20) /* ADC SADCIN Data Register */ + +#define REG_SADC_ENA REG8(SADC_ENA) +#define REG_SADC_CFG REG32(SADC_CFG) +#define REG_SADC_CTRL REG8(SADC_CTRL) +#define REG_SADC_STATE REG8(SADC_STATE) +#define REG_SADC_SAMETIME REG16(SADC_SAMETIME) +#define REG_SADC_WAITTIME REG16(SADC_WAITTIME) +#define REG_SADC_TSDAT REG32(SADC_TSDAT) +#define REG_SADC_BATDAT REG16(SADC_BATDAT) +#define REG_SADC_SADDAT REG16(SADC_SADDAT) + +/* ADC Enable Register */ +#define SADC_ENA_ADEN (1 << 7) /* Touch Screen Enable */ +#define SADC_ENA_TSEN (1 << 2) /* Touch Screen Enable */ +#define SADC_ENA_PBATEN (1 << 1) /* PBAT Enable */ +#define SADC_ENA_SADCINEN (1 << 0) /* SADCIN Enable */ + +/* ADC Configure Register */ +#define SADC_CFG_CLKOUT_NUM_BIT 16 +#define SADC_CFG_CLKOUT_NUM_MASK (0x7 << SADC_CFG_CLKOUT_NUM_BIT) +#define SADC_CFG_TS_DMA (1 << 15) /* Touch Screen DMA Enable */ +#define SADC_CFG_XYZ_BIT 13 /* XYZ selection */ +#define SADC_CFG_XYZ_MASK (0x3 << SADC_CFG_XYZ_BIT) + #define SADC_CFG_XY (0 << SADC_CFG_XYZ_BIT) + #define SADC_CFG_XYZ (1 << SADC_CFG_XYZ_BIT) + #define SADC_CFG_XYZ1Z2 (2 << SADC_CFG_XYZ_BIT) +#define SADC_CFG_SNUM_BIT 10 /* Sample Number */ +#define SADC_CFG_SNUM_MASK (0x7 << SADC_CFG_SNUM_BIT) + #define SADC_CFG_SNUM_1 (0x0 << SADC_CFG_SNUM_BIT) + #define SADC_CFG_SNUM_2 (0x1 << SADC_CFG_SNUM_BIT) + #define SADC_CFG_SNUM_3 (0x2 << SADC_CFG_SNUM_BIT) + #define SADC_CFG_SNUM_4 (0x3 << SADC_CFG_SNUM_BIT) + #define SADC_CFG_SNUM_5 (0x4 << SADC_CFG_SNUM_BIT) + #define SADC_CFG_SNUM_6 (0x5 << SADC_CFG_SNUM_BIT) + #define SADC_CFG_SNUM_8 (0x6 << SADC_CFG_SNUM_BIT) + #define SADC_CFG_SNUM_9 (0x7 << SADC_CFG_SNUM_BIT) +#define SADC_CFG_CLKDIV_BIT 5 /* AD Converter frequency clock divider */ +#define SADC_CFG_CLKDIV_MASK (0x1f << SADC_CFG_CLKDIV_BIT) +#define SADC_CFG_PBAT_HIGH (0 << 4) /* PBAT >= 2.5V */ +#define SADC_CFG_PBAT_LOW (1 << 4) /* PBAT < 2.5V */ +#define SADC_CFG_CMD_BIT 0 /* ADC Command */ +#define SADC_CFG_CMD_MASK (0xf << SADC_CFG_CMD_BIT) + #define SADC_CFG_CMD_X_SE (0x0 << SADC_CFG_CMD_BIT) /* X Single-End */ + #define SADC_CFG_CMD_Y_SE (0x1 << SADC_CFG_CMD_BIT) /* Y Single-End */ + #define SADC_CFG_CMD_X_DIFF (0x2 << SADC_CFG_CMD_BIT) /* X Differential */ + #define SADC_CFG_CMD_Y_DIFF (0x3 << SADC_CFG_CMD_BIT) /* Y Differential */ + #define SADC_CFG_CMD_Z1_DIFF (0x4 << SADC_CFG_CMD_BIT) /* Z1 Differential */ + #define SADC_CFG_CMD_Z2_DIFF (0x5 << SADC_CFG_CMD_BIT) /* Z2 Differential */ + #define SADC_CFG_CMD_Z3_DIFF (0x6 << SADC_CFG_CMD_BIT) /* Z3 Differential */ + #define SADC_CFG_CMD_Z4_DIFF (0x7 << SADC_CFG_CMD_BIT) /* Z4 Differential */ + #define SADC_CFG_CMD_TP_SE (0x8 << SADC_CFG_CMD_BIT) /* Touch Pressure */ + #define SADC_CFG_CMD_PBATH_SE (0x9 << SADC_CFG_CMD_BIT) /* PBAT >= 2.5V */ + #define SADC_CFG_CMD_PBATL_SE (0xa << SADC_CFG_CMD_BIT) /* PBAT < 2.5V */ + #define SADC_CFG_CMD_SADCIN_SE (0xb << SADC_CFG_CMD_BIT) /* Measure SADCIN */ + #define SADC_CFG_CMD_INT_PEN (0xc << SADC_CFG_CMD_BIT) /* INT_PEN Enable */ + +/* ADC Control Register */ +#define SADC_CTRL_PENDM (1 << 4) /* Pen Down Interrupt Mask */ +#define SADC_CTRL_PENUM (1 << 3) /* Pen Up Interrupt Mask */ +#define SADC_CTRL_TSRDYM (1 << 2) /* Touch Screen Data Ready Interrupt Mask */ +#define SADC_CTRL_PBATRDYM (1 << 1) /* PBAT Data Ready Interrupt Mask */ +#define SADC_CTRL_SRDYM (1 << 0) /* SADCIN Data Ready Interrupt Mask */ + +/* ADC Status Register */ +#define SADC_STATE_TSBUSY (1 << 7) /* TS A/D is working */ +#define SADC_STATE_PBATBUSY (1 << 6) /* PBAT A/D is working */ +#define SADC_STATE_SBUSY (1 << 5) /* SADCIN A/D is working */ +#define SADC_STATE_PEND (1 << 4) /* Pen Down Interrupt Flag */ +#define SADC_STATE_PENU (1 << 3) /* Pen Up Interrupt Flag */ +#define SADC_STATE_TSRDY (1 << 2) /* Touch Screen Data Ready Interrupt Flag */ +#define SADC_STATE_PBATRDY (1 << 1) /* PBAT Data Ready Interrupt Flag */ +#define SADC_STATE_SRDY (1 << 0) /* SADCIN Data Ready Interrupt Flag */ + +/* ADC Touch Screen Data Register */ +#define SADC_TSDAT_DATA0_BIT 0 +#define SADC_TSDAT_DATA0_MASK (0xfff << SADC_TSDAT_DATA0_BIT) +#define SADC_TSDAT_TYPE0 (1 << 15) +#define SADC_TSDAT_DATA1_BIT 16 +#define SADC_TSDAT_DATA1_MASK (0xfff << SADC_TSDAT_DATA1_BIT) +#define SADC_TSDAT_TYPE1 (1 << 31) + + +/************************************************************************* + * SLCD (Smart LCD Controller) + *************************************************************************/ + +#define SLCD_CFG (SLCD_BASE + 0xA0) /* SLCD Configure Register */ +#define SLCD_CTRL (SLCD_BASE + 0xA4) /* SLCD Control Register */ +#define SLCD_STATE (SLCD_BASE + 0xA8) /* SLCD Status Register */ +#define SLCD_DATA (SLCD_BASE + 0xAC) /* SLCD Data Register */ +#define SLCD_FIFO (SLCD_BASE + 0xB0) /* SLCD FIFO Register */ + +#define REG_SLCD_CFG REG32(SLCD_CFG) +#define REG_SLCD_CTRL REG8(SLCD_CTRL) +#define REG_SLCD_STATE REG8(SLCD_STATE) +#define REG_SLCD_DATA REG32(SLCD_DATA) +#define REG_SLCD_FIFO REG32(SLCD_FIFO) + +/* SLCD Configure Register */ +#define SLCD_CFG_BURST_BIT 14 +#define SLCD_CFG_BURST_MASK (0x3 << SLCD_CFG_BURST_BIT) + #define SLCD_CFG_BURST_4_WORD (0 << SLCD_CFG_BURST_BIT) + #define SLCD_CFG_BURST_8_WORD (1 << SLCD_CFG_BURST_BIT) +#define SLCD_CFG_DWIDTH_BIT 10 +#define SLCD_CFG_DWIDTH_MASK (0x7 << SLCD_CFG_DWIDTH_BIT) + #define SLCD_CFG_DWIDTH_18 (0 << SLCD_CFG_DWIDTH_BIT) + #define SLCD_CFG_DWIDTH_16 (1 << SLCD_CFG_DWIDTH_BIT) + #define SLCD_CFG_DWIDTH_8_x3 (2 << SLCD_CFG_DWIDTH_BIT) + #define SLCD_CFG_DWIDTH_8_x2 (3 << SLCD_CFG_DWIDTH_BIT) + #define SLCD_CFG_DWIDTH_9_x2 (4 << SLCD_CFG_DWIDTH_BIT) +#define SLCD_CFG_CWIDTH_16BIT (0 << 8) +#define SLCD_CFG_CWIDTH_8BIT (1 << 8) +#define SLCD_CFG_CS_ACTIVE_LOW (0 << 4) +#define SLCD_CFG_CS_ACTIVE_HIGH (1 << 4) +#define SLCD_CFG_RS_CMD_LOW (0 << 3) +#define SLCD_CFG_RS_CMD_HIGH (1 << 3) +#define SLCD_CFG_CLK_ACTIVE_FALLING (0 << 1) +#define SLCD_CFG_CLK_ACTIVE_RISING (1 << 1) +#define SLCD_CFG_TYPE_PARALLEL (0 << 0) +#define SLCD_CFG_TYPE_SERIAL (1 << 0) + +/* SLCD Control Register */ +#define SLCD_CTRL_DMA_EN (1 << 0) + +/* SLCD Status Register */ +#define SLCD_STATE_BUSY (1 << 0) + +/* SLCD Data Register */ +#define SLCD_DATA_RS_DATA (0 << 31) +#define SLCD_DATA_RS_COMMAND (1 << 31) + +/* SLCD FIFO Register */ +#define SLCD_FIFO_RS_DATA (0 << 31) +#define SLCD_FIFO_RS_COMMAND (1 << 31) + + +/************************************************************************* + * LCD (LCD Controller) + *************************************************************************/ +#define LCD_CFG (LCD_BASE + 0x00) /* LCD Configure Register */ +#define LCD_VSYNC (LCD_BASE + 0x04) /* Vertical Synchronize Register */ +#define LCD_HSYNC (LCD_BASE + 0x08) /* Horizontal Synchronize Register */ +#define LCD_VAT (LCD_BASE + 0x0c) /* Virtual Area Setting Register */ +#define LCD_DAH (LCD_BASE + 0x10) /* Display Area Horizontal Start/End Point */ +#define LCD_DAV (LCD_BASE + 0x14) /* Display Area Vertical Start/End Point */ +#define LCD_PS (LCD_BASE + 0x18) /* PS Signal Setting */ +#define LCD_CLS (LCD_BASE + 0x1c) /* CLS Signal Setting */ +#define LCD_SPL (LCD_BASE + 0x20) /* SPL Signal Setting */ +#define LCD_REV (LCD_BASE + 0x24) /* REV Signal Setting */ +#define LCD_CTRL (LCD_BASE + 0x30) /* LCD Control Register */ +#define LCD_STATE (LCD_BASE + 0x34) /* LCD Status Register */ +#define LCD_IID (LCD_BASE + 0x38) /* Interrupt ID Register */ +#define LCD_DA0 (LCD_BASE + 0x40) /* Descriptor Address Register 0 */ +#define LCD_SA0 (LCD_BASE + 0x44) /* Source Address Register 0 */ +#define LCD_FID0 (LCD_BASE + 0x48) /* Frame ID Register 0 */ +#define LCD_CMD0 (LCD_BASE + 0x4c) /* DMA Command Register 0 */ +#define LCD_DA1 (LCD_BASE + 0x50) /* Descriptor Address Register 1 */ +#define LCD_SA1 (LCD_BASE + 0x54) /* Source Address Register 1 */ +#define LCD_FID1 (LCD_BASE + 0x58) /* Frame ID Register 1 */ +#define LCD_CMD1 (LCD_BASE + 0x5c) /* DMA Command Register 1 */ + +#define REG_LCD_CFG REG32(LCD_CFG) +#define REG_LCD_VSYNC REG32(LCD_VSYNC) +#define REG_LCD_HSYNC REG32(LCD_HSYNC) +#define REG_LCD_VAT REG32(LCD_VAT) +#define REG_LCD_DAH REG32(LCD_DAH) +#define REG_LCD_DAV REG32(LCD_DAV) +#define REG_LCD_PS REG32(LCD_PS) +#define REG_LCD_CLS REG32(LCD_CLS) +#define REG_LCD_SPL REG32(LCD_SPL) +#define REG_LCD_REV REG32(LCD_REV) +#define REG_LCD_CTRL REG32(LCD_CTRL) +#define REG_LCD_STATE REG32(LCD_STATE) +#define REG_LCD_IID REG32(LCD_IID) +#define REG_LCD_DA0 REG32(LCD_DA0) +#define REG_LCD_SA0 REG32(LCD_SA0) +#define REG_LCD_FID0 REG32(LCD_FID0) +#define REG_LCD_CMD0 REG32(LCD_CMD0) +#define REG_LCD_DA1 REG32(LCD_DA1) +#define REG_LCD_SA1 REG32(LCD_SA1) +#define REG_LCD_FID1 REG32(LCD_FID1) +#define REG_LCD_CMD1 REG32(LCD_CMD1) + +/* LCD Configure Register */ +#define LCD_CFG_LCDPIN_BIT 31 /* LCD pins selection */ +#define LCD_CFG_LCDPIN_MASK (0x1 << LCD_CFG_LCDPIN_BIT) + #define LCD_CFG_LCDPIN_LCD (0x0 << LCD_CFG_LCDPIN_BIT) + #define LCD_CFG_LCDPIN_SLCD (0x1 << LCD_CFG_LCDPIN_BIT) +#define LCD_CFG_PSM (1 << 23) /* PS signal mode */ +#define LCD_CFG_CLSM (1 << 22) /* CLS signal mode */ +#define LCD_CFG_SPLM (1 << 21) /* SPL signal mode */ +#define LCD_CFG_REVM (1 << 20) /* REV signal mode */ +#define LCD_CFG_HSYNM (1 << 19) /* HSYNC signal mode */ +#define LCD_CFG_PCLKM (1 << 18) /* PCLK signal mode */ +#define LCD_CFG_INVDAT (1 << 17) /* Inverse output data */ +#define LCD_CFG_SYNDIR_IN (1 << 16) /* VSYNC&HSYNC direction */ +#define LCD_CFG_PSP (1 << 15) /* PS pin reset state */ +#define LCD_CFG_CLSP (1 << 14) /* CLS pin reset state */ +#define LCD_CFG_SPLP (1 << 13) /* SPL pin reset state */ +#define LCD_CFG_REVP (1 << 12) /* REV pin reset state */ +#define LCD_CFG_HSP (1 << 11) /* HSYNC pority:0-active high,1-active low */ +#define LCD_CFG_PCP (1 << 10) /* PCLK pority:0-rising,1-falling */ +#define LCD_CFG_DEP (1 << 9) /* DE pority:0-active high,1-active low */ +#define LCD_CFG_VSP (1 << 8) /* VSYNC pority:0-rising,1-falling */ +#define LCD_CFG_PDW_BIT 4 /* STN pins utilization */ +#define LCD_CFG_PDW_MASK (0x3 << LCD_DEV_PDW_BIT) +#define LCD_CFG_PDW_1 (0 << LCD_CFG_PDW_BIT) /* LCD_D[0] */ + #define LCD_CFG_PDW_2 (1 << LCD_CFG_PDW_BIT) /* LCD_D[0:1] */ + #define LCD_CFG_PDW_4 (2 << LCD_CFG_PDW_BIT) /* LCD_D[0:3]/LCD_D[8:11] */ + #define LCD_CFG_PDW_8 (3 << LCD_CFG_PDW_BIT) /* LCD_D[0:7]/LCD_D[8:15] */ +#define LCD_CFG_MODE_BIT 0 /* Display Device Mode Select */ +#define LCD_CFG_MODE_MASK (0x0f << LCD_CFG_MODE_BIT) + #define LCD_CFG_MODE_GENERIC_TFT (0 << LCD_CFG_MODE_BIT) /* 16,18 bit TFT */ + #define LCD_CFG_MODE_SPECIAL_TFT_1 (1 << LCD_CFG_MODE_BIT) + #define LCD_CFG_MODE_SPECIAL_TFT_2 (2 << LCD_CFG_MODE_BIT) + #define LCD_CFG_MODE_SPECIAL_TFT_3 (3 << LCD_CFG_MODE_BIT) + #define LCD_CFG_MODE_NONINTER_CCIR656 (4 << LCD_CFG_MODE_BIT) + #define LCD_CFG_MODE_INTER_CCIR656 (5 << LCD_CFG_MODE_BIT) + #define LCD_CFG_MODE_SINGLE_CSTN (8 << LCD_CFG_MODE_BIT) + #define LCD_CFG_MODE_SINGLE_MSTN (9 << LCD_CFG_MODE_BIT) + #define LCD_CFG_MODE_DUAL_CSTN (10 << LCD_CFG_MODE_BIT) + #define LCD_CFG_MODE_DUAL_MSTN (11 << LCD_CFG_MODE_BIT) + #define LCD_CFG_MODE_SERIAL_TFT (12 << LCD_CFG_MODE_BIT) + #define LCD_CFG_MODE_GENERIC_18BIT_TFT (13 << LCD_CFG_MODE_BIT) + /* JZ47XX defines */ + #define LCD_CFG_MODE_SHARP_HR (1 << LCD_CFG_MODE_BIT) + #define LCD_CFG_MODE_CASIO_TFT (2 << LCD_CFG_MODE_BIT) + #define LCD_CFG_MODE_SAMSUNG_ALPHA (3 << LCD_CFG_MODE_BIT) + + + +/* Vertical Synchronize Register */ +#define LCD_VSYNC_VPS_BIT 16 /* VSYNC pulse start in line clock, fixed to 0 */ +#define LCD_VSYNC_VPS_MASK (0xffff << LCD_VSYNC_VPS_BIT) +#define LCD_VSYNC_VPE_BIT 0 /* VSYNC pulse end in line clock */ +#define LCD_VSYNC_VPE_MASK (0xffff << LCD_VSYNC_VPS_BIT) + +/* Horizontal Synchronize Register */ +#define LCD_HSYNC_HPS_BIT 16 /* HSYNC pulse start position in dot clock */ +#define LCD_HSYNC_HPS_MASK (0xffff << LCD_HSYNC_HPS_BIT) +#define LCD_HSYNC_HPE_BIT 0 /* HSYNC pulse end position in dot clock */ +#define LCD_HSYNC_HPE_MASK (0xffff << LCD_HSYNC_HPE_BIT) + +/* Virtual Area Setting Register */ +#define LCD_VAT_HT_BIT 16 /* Horizontal Total size in dot clock */ +#define LCD_VAT_HT_MASK (0xffff << LCD_VAT_HT_BIT) +#define LCD_VAT_VT_BIT 0 /* Vertical Total size in dot clock */ +#define LCD_VAT_VT_MASK (0xffff << LCD_VAT_VT_BIT) + +/* Display Area Horizontal Start/End Point Register */ +#define LCD_DAH_HDS_BIT 16 /* Horizontal display area start in dot clock */ +#define LCD_DAH_HDS_MASK (0xffff << LCD_DAH_HDS_BIT) +#define LCD_DAH_HDE_BIT 0 /* Horizontal display area end in dot clock */ +#define LCD_DAH_HDE_MASK (0xffff << LCD_DAH_HDE_BIT) + +/* Display Area Vertical Start/End Point Register */ +#define LCD_DAV_VDS_BIT 16 /* Vertical display area start in line clock */ +#define LCD_DAV_VDS_MASK (0xffff << LCD_DAV_VDS_BIT) +#define LCD_DAV_VDE_BIT 0 /* Vertical display area end in line clock */ +#define LCD_DAV_VDE_MASK (0xffff << LCD_DAV_VDE_BIT) + +/* PS Signal Setting */ +#define LCD_PS_PSS_BIT 16 /* PS signal start position in dot clock */ +#define LCD_PS_PSS_MASK (0xffff << LCD_PS_PSS_BIT) +#define LCD_PS_PSE_BIT 0 /* PS signal end position in dot clock */ +#define LCD_PS_PSE_MASK (0xffff << LCD_PS_PSE_BIT) + +/* CLS Signal Setting */ +#define LCD_CLS_CLSS_BIT 16 /* CLS signal start position in dot clock */ +#define LCD_CLS_CLSS_MASK (0xffff << LCD_CLS_CLSS_BIT) +#define LCD_CLS_CLSE_BIT 0 /* CLS signal end position in dot clock */ +#define LCD_CLS_CLSE_MASK (0xffff << LCD_CLS_CLSE_BIT) + +/* SPL Signal Setting */ +#define LCD_SPL_SPLS_BIT 16 /* SPL signal start position in dot clock */ +#define LCD_SPL_SPLS_MASK (0xffff << LCD_SPL_SPLS_BIT) +#define LCD_SPL_SPLE_BIT 0 /* SPL signal end position in dot clock */ +#define LCD_SPL_SPLE_MASK (0xffff << LCD_SPL_SPLE_BIT) + +/* REV Signal Setting */ +#define LCD_REV_REVS_BIT 16 /* REV signal start position in dot clock */ +#define LCD_REV_REVS_MASK (0xffff << LCD_REV_REVS_BIT) + +/* LCD Control Register */ +#define LCD_CTRL_BST_BIT 28 /* Burst Length Selection */ +#define LCD_CTRL_BST_MASK (0x03 << LCD_CTRL_BST_BIT) + #define LCD_CTRL_BST_4 (0 << LCD_CTRL_BST_BIT) /* 4-word */ + #define LCD_CTRL_BST_8 (1 << LCD_CTRL_BST_BIT) /* 8-word */ + #define LCD_CTRL_BST_16 (2 << LCD_CTRL_BST_BIT) /* 16-word */ +#define LCD_CTRL_RGB565 (0 << 27) /* RGB565 mode */ +#define LCD_CTRL_RGB555 (1 << 27) /* RGB555 mode */ +#define LCD_CTRL_OFUP (1 << 26) /* Output FIFO underrun protection enable */ +#define LCD_CTRL_FRC_BIT 24 /* STN FRC Algorithm Selection */ +#define LCD_CTRL_FRC_MASK (0x03 << LCD_CTRL_FRC_BIT) + #define LCD_CTRL_FRC_16 (0 << LCD_CTRL_FRC_BIT) /* 16 grayscale */ + #define LCD_CTRL_FRC_4 (1 << LCD_CTRL_FRC_BIT) /* 4 grayscale */ + #define LCD_CTRL_FRC_2 (2 << LCD_CTRL_FRC_BIT) /* 2 grayscale */ +#define LCD_CTRL_PDD_BIT 16 /* Load Palette Delay Counter */ +#define LCD_CTRL_PDD_MASK (0xff << LCD_CTRL_PDD_BIT) +#define LCD_CTRL_EOFM (1 << 13) /* EOF interrupt mask */ +#define LCD_CTRL_SOFM (1 << 12) /* SOF interrupt mask */ +#define LCD_CTRL_OFUM (1 << 11) /* Output FIFO underrun interrupt mask */ +#define LCD_CTRL_IFUM0 (1 << 10) /* Input FIFO 0 underrun interrupt mask */ +#define LCD_CTRL_IFUM1 (1 << 9) /* Input FIFO 1 underrun interrupt mask */ +#define LCD_CTRL_LDDM (1 << 8) /* LCD disable done interrupt mask */ +#define LCD_CTRL_QDM (1 << 7) /* LCD quick disable done interrupt mask */ +#define LCD_CTRL_BEDN (1 << 6) /* Endian selection */ +#define LCD_CTRL_PEDN (1 << 5) /* Endian in byte:0-msb first, 1-lsb first */ +#define LCD_CTRL_DIS (1 << 4) /* Disable indicate bit */ +#define LCD_CTRL_ENA (1 << 3) /* LCD enable bit */ +#define LCD_CTRL_BPP_BIT 0 /* Bits Per Pixel */ +#define LCD_CTRL_BPP_MASK (0x07 << LCD_CTRL_BPP_BIT) + #define LCD_CTRL_BPP_1 (0 << LCD_CTRL_BPP_BIT) /* 1 bpp */ + #define LCD_CTRL_BPP_2 (1 << LCD_CTRL_BPP_BIT) /* 2 bpp */ + #define LCD_CTRL_BPP_4 (2 << LCD_CTRL_BPP_BIT) /* 4 bpp */ + #define LCD_CTRL_BPP_8 (3 << LCD_CTRL_BPP_BIT) /* 8 bpp */ + #define LCD_CTRL_BPP_16 (4 << LCD_CTRL_BPP_BIT) /* 15/16 bpp */ + #define LCD_CTRL_BPP_18_24 (5 << LCD_CTRL_BPP_BIT) /* 18/24/32 bpp */ + +/* LCD Status Register */ +#define LCD_STATE_QD (1 << 7) /* Quick Disable Done */ +#define LCD_STATE_EOF (1 << 5) /* EOF Flag */ +#define LCD_STATE_SOF (1 << 4) /* SOF Flag */ +#define LCD_STATE_OFU (1 << 3) /* Output FIFO Underrun */ +#define LCD_STATE_IFU0 (1 << 2) /* Input FIFO 0 Underrun */ +#define LCD_STATE_IFU1 (1 << 1) /* Input FIFO 1 Underrun */ +#define LCD_STATE_LDD (1 << 0) /* LCD Disabled */ + +/* DMA Command Register */ +#define LCD_CMD_SOFINT (1 << 31) +#define LCD_CMD_EOFINT (1 << 30) +#define LCD_CMD_PAL (1 << 28) +#define LCD_CMD_LEN_BIT 0 +#define LCD_CMD_LEN_MASK (0xffffff << LCD_CMD_LEN_BIT) + + +/************************************************************************* + * USB Device + *************************************************************************/ +#define USB_BASE UDC_BASE + +#define USB_REG_FADDR (USB_BASE + 0x00) /* Function Address 8-bit */ +#define USB_REG_POWER (USB_BASE + 0x01) /* Power Managemetn 8-bit */ +#define USB_REG_INTRIN (USB_BASE + 0x02) /* Interrupt IN 16-bit */ +#define USB_REG_INTROUT (USB_BASE + 0x04) /* Interrupt OUT 16-bit */ +#define USB_REG_INTRINE (USB_BASE + 0x06) /* Intr IN enable 16-bit */ +#define USB_REG_INTROUTE (USB_BASE + 0x08) /* Intr OUT enable 16-bit */ +#define USB_REG_INTRUSB (USB_BASE + 0x0a) /* Interrupt USB 8-bit */ +#define USB_REG_INTRUSBE (USB_BASE + 0x0b) /* Interrupt USB Enable 8-bit */ +#define USB_REG_FRAME (USB_BASE + 0x0c) /* Frame number 16-bit */ +#define USB_REG_INDEX (USB_BASE + 0x0e) /* Index register 8-bit */ +#define USB_REG_TESTMODE (USB_BASE + 0x0f) /* USB test mode 8-bit */ + +#define USB_REG_CSR0 (USB_BASE + 0x12) /* EP0 CSR 8-bit */ +#define USB_REG_INMAXP (USB_BASE + 0x10) /* EP1-2 IN Max Pkt Size 16-bit */ +#define USB_REG_INCSR (USB_BASE + 0x12) /* EP1-2 IN CSR LSB 8/16bit */ +#define USB_REG_INCSRH (USB_BASE + 0x13) /* EP1-2 IN CSR MSB 8-bit */ +#define USB_REG_OUTMAXP (USB_BASE + 0x14) /* EP1 OUT Max Pkt Size 16-bit */ +#define USB_REG_OUTCSR (USB_BASE + 0x16) /* EP1 OUT CSR LSB 8/16bit */ +#define USB_REG_OUTCSRH (USB_BASE + 0x17) /* EP1 OUT CSR MSB 8-bit */ +#define USB_REG_OUTCOUNT (USB_BASE + 0x18) /* bytes in EP0/1 OUT FIFO 16-bit */ + +#define USB_FIFO_EP0 (USB_BASE + 0x20) +#define USB_FIFO_EP1 (USB_BASE + 0x24) +#define USB_FIFO_EP2 (USB_BASE + 0x28) + +#define USB_REG_EPINFO (USB_BASE + 0x78) /* Endpoint information */ +#define USB_REG_RAMINFO (USB_BASE + 0x79) /* RAM information */ + +#define USB_REG_INTR (USB_BASE + 0x200) /* DMA pending interrupts */ +#define USB_REG_CNTL1 (USB_BASE + 0x204) /* DMA channel 1 control */ +#define USB_REG_ADDR1 (USB_BASE + 0x208) /* DMA channel 1 AHB memory addr */ +#define USB_REG_COUNT1 (USB_BASE + 0x20c) /* DMA channel 1 byte count */ +#define USB_REG_CNTL2 (USB_BASE + 0x214) /* DMA channel 2 control */ +#define USB_REG_ADDR2 (USB_BASE + 0x218) /* DMA channel 2 AHB memory addr */ +#define USB_REG_COUNT2 (USB_BASE + 0x21c) /* DMA channel 2 byte count */ + + +/* Power register bit masks */ +#define USB_POWER_SUSPENDM 0x01 +#define USB_POWER_RESUME 0x04 +#define USB_POWER_HSMODE 0x10 +#define USB_POWER_HSENAB 0x20 +#define USB_POWER_SOFTCONN 0x40 + +/* Interrupt register bit masks */ +#define USB_INTR_SUSPEND 0x01 +#define USB_INTR_RESUME 0x02 +#define USB_INTR_RESET 0x04 + +#define USB_INTR_EP0 0x0001 +#define USB_INTR_INEP1 0x0002 +#define USB_INTR_INEP2 0x0004 +#define USB_INTR_OUTEP1 0x0002 + +/* CSR0 bit masks */ +#define USB_CSR0_OUTPKTRDY 0x01 +#define USB_CSR0_INPKTRDY 0x02 +#define USB_CSR0_SENTSTALL 0x04 +#define USB_CSR0_DATAEND 0x08 +#define USB_CSR0_SETUPEND 0x10 +#define USB_CSR0_SENDSTALL 0x20 +#define USB_CSR0_SVDOUTPKTRDY 0x40 +#define USB_CSR0_SVDSETUPEND 0x80 + +/* Endpoint CSR register bits */ +#define USB_INCSRH_AUTOSET 0x80 +#define USB_INCSRH_ISO 0x40 +#define USB_INCSRH_MODE 0x20 +#define USB_INCSRH_DMAREQENAB 0x10 +#define USB_INCSRH_DMAREQMODE 0x04 +#define USB_INCSR_CDT 0x40 +#define USB_INCSR_SENTSTALL 0x20 +#define USB_INCSR_SENDSTALL 0x10 +#define USB_INCSR_FF 0x08 +#define USB_INCSR_UNDERRUN 0x04 +#define USB_INCSR_FFNOTEMPT 0x02 +#define USB_INCSR_INPKTRDY 0x01 +#define USB_OUTCSRH_AUTOCLR 0x80 +#define USB_OUTCSRH_ISO 0x40 +#define USB_OUTCSRH_DMAREQENAB 0x20 +#define USB_OUTCSRH_DNYT 0x10 +#define USB_OUTCSRH_DMAREQMODE 0x08 +#define USB_OUTCSR_CDT 0x80 +#define USB_OUTCSR_SENTSTALL 0x40 +#define USB_OUTCSR_SENDSTALL 0x20 +#define USB_OUTCSR_FF 0x10 +#define USB_OUTCSR_DATAERR 0x08 +#define USB_OUTCSR_OVERRUN 0x04 +#define USB_OUTCSR_FFFULL 0x02 +#define USB_OUTCSR_OUTPKTRDY 0x01 + +/* Testmode register bits */ +#define USB_TEST_SE0NAK 0x01 +#define USB_TEST_J 0x02 +#define USB_TEST_K 0x04 +#define USB_TEST_PACKET 0x08 + +/* DMA control bits */ +#define USB_CNTL_ENA 0x01 +#define USB_CNTL_DIR_IN 0x02 +#define USB_CNTL_MODE_1 0x04 +#define USB_CNTL_INTR_EN 0x08 +#define USB_CNTL_EP(n) ((n) << 4) +#define USB_CNTL_BURST_0 (0 << 9) +#define USB_CNTL_BURST_4 (1 << 9) +#define USB_CNTL_BURST_8 (2 << 9) +#define USB_CNTL_BURST_16 (3 << 9) + +#endif /* __JZ4740_H__ */ diff --git a/utils/jz4740_usbtool/jz4740_usbtool.c b/utils/jz4740_usbtool/jz4740_usbtool.c new file mode 100755 index 0000000000..908cf723d0 --- /dev/null +++ b/utils/jz4740_usbtool/jz4740_usbtool.c @@ -0,0 +1,477 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2008 by Maurus Cuelenaere + * + * based on tcctool.c by Dave Chapman + * + * USB code based on ifp-line - http://ifp-driver.sourceforge.net + * + * ifp-line is (C) Pavel Kriz, Jun Yamishiro and Joe Roback and + * licensed under the GPL (v2) + * + * + * All files in this archive are subject to the GNU General Public License. + * See the file COPYING in the source tree root for full license agreement. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "jz4740.h" + +#define VERSION "0.2" + +#define MAX_FIRMWARESIZE (64*1024*1024) /* Arbitrary limit (for safety) */ + +/* For win32 compatibility: */ +#ifndef O_BINARY +#define O_BINARY 0 +#endif + +/* USB IDs for USB Boot Mode */ +#define VID 0x601A +#define PID 0x4740 + +#define EP_BULK_TO 0x01 +#define TOUT 5000 + +#ifndef MAX +#define MAX(a,b) (((a)>(b))?(a):(b)) +#endif + +enum USB_JZ4740_REQUEST +{ + VR_GET_CPU_INFO = 0, + VR_SET_DATA_ADDRESS, + VR_SET_DATA_LENGTH, + VR_FLUSH_CACHES, + VR_PROGRAM_START1, + VR_PROGRAM_START2, + VR_NOR_OPS, + VR_NAND_OPS, + VR_SDRAM_OPS, + VR_CONFIGURATION +}; + +enum NOR_OPS_TYPE +{ + NOR_INIT = 0, + NOR_QUERY, + NOR_WRITE, + NOR_ERASE_CHIP, + NOR_ERASE_SECTOR +}; + +enum NOR_FLASH_TYPE +{ + NOR_AM29 = 0, + NOR_SST28, + NOR_SST39x16, + NOR_SST39x8 +}; + +enum NAND_OPS_TYPE +{ + NAND_QUERY = 0, + NAND_INIT, + NAND_MARK_BAD, + NAND_READ_OOB, + NAND_READ_RAW, + NAND_ERASE, + NAND_READ, + NAND_PROGRAM, + NAND_READ_TO_RAM +}; + +enum SDRAM_OPS_TYPE +{ + SDRAM_LOAD, + +}; + +enum DATA_STRUCTURE_OB +{ + DS_flash_info , + DS_hand +}; + +enum OPTION +{ + OOB_ECC, + OOB_NO_ECC, + NO_OOB, +}; + +#define SEND_COMMAND(cmd, arg) err = usb_control_msg(dh, USB_ENDPOINT_OUT | USB_TYPE_VENDOR, cmd, arg>>16, arg&0xFFFF, NULL, 0, TOUT);\ + if (err < 0) \ + { \ + fprintf(stderr,"\n[ERR] Error sending control message (%d, %s)\n", err, usb_strerror()); \ + return -1; \ + } + +#define GET_CPU_INFO(s) err = usb_control_msg(dh, USB_ENDPOINT_IN | USB_TYPE_VENDOR, VR_GET_CPU_INFO, 0, 0, buf, 8, TOUT); \ + if (err < 0) \ + { \ + fprintf(stderr,"\n[ERR] Error sending control message (%d, %s)\n", err, usb_strerror()); \ + return -1; \ + } + +#define SEND_DATA(ptr, size) err = usb_bulk_write(dh, USB_ENDPOINT_OUT | EP_BULK_TO, ptr, size, TOUT); \ + if (err != len) \ + { \ + fprintf(stderr,"\n[ERR] Error writing data\n"); \ + fprintf(stderr,"[ERR] Bulk write error (%d, %s)\n", err, strerror(-err)); \ + return -1; \ + } + +#define GET_DATA(ptr, size) err = usb_bulk_read(dh, USB_ENDPOINT_IN | EP_BULK_TO, ptr, size, TOUT); \ + if (err != size) \ + { \ + fprintf(stderr,"\n[ERR] Error writing data\n"); \ + fprintf(stderr,"[ERR] Bulk write error (%d, %s)\n", err, strerror(-err)); \ + return -1; \ + } + +int upload_app(usb_dev_handle* dh, int address, unsigned char* p, int len) +{ + int err; + char buf[8]; + unsigned char* tmp_buf; + + fprintf(stderr, "[INFO] GET_CPU_INFO: "); + GET_CPU_INFO(buf); + buf[8] = 0; + fprintf(stderr, "%s\n", buf); + + fprintf(stderr, "[INFO] SET_DATA_ADDRESS to 0x%x...", address); + SEND_COMMAND(VR_SET_DATA_ADDRESS, address); + fprintf(stderr, " Done!\n"); + + fprintf(stderr, "[INFO] Sending data..."); + /* Must not split the file in several packages! */ + SEND_DATA(p, len); + fprintf(stderr, " Done!\n"); + + fprintf(stderr, "[INFO] Verifying data..."); + SEND_COMMAND(VR_SET_DATA_ADDRESS, address); + SEND_COMMAND(VR_SET_DATA_LENGTH, len); + tmp_buf = malloc(len); + if (tmp_buf == NULL) + { + fprintf(stderr, "\n[ERR] Could not allocate memory.\n"); + return -1; + } + GET_DATA(tmp_buf, len); + if (memcmp(tmp_buf, p, len) != 0) + { + fprintf(stderr, "\n[ERR] Sent data isn't the same as received data...\n"); + free(tmp_buf); + return -1; + } + free(tmp_buf); + fprintf(stderr, " Done !\n"); + + fprintf(stderr, "[INFO] Booting device..."); + SEND_COMMAND(VR_PROGRAM_START1, address); + fprintf(stderr, " Done!\n"); + + return 0; +} + +int read_data(usb_dev_handle* dh, int address, unsigned char *p, int len) +{ + int err; + char buf[8]; + + fprintf(stderr, "[INFO] GET_CPU_INFO: "); + GET_CPU_INFO(buf); + buf[8] = 0; + fprintf(stderr, "%s\n", buf); + + fprintf(stderr, "[INFO] Reading data..."); + SEND_COMMAND(VR_SET_DATA_ADDRESS, address); + SEND_COMMAND(VR_SET_DATA_LENGTH, len); + GET_DATA(p, len); + fprintf(stderr, " Done!\n"); + return 0; +} + +unsigned int read_reg(usb_dev_handle* dh, int address) +{ + int err; + unsigned char buf[4]; + + SEND_COMMAND(VR_SET_DATA_ADDRESS, address); + SEND_COMMAND(VR_SET_DATA_LENGTH, 4); + GET_DATA(buf, 4); + + return (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0]; +} + +#define TEST(m) fprintf(stderr, "%s -> %x\n", #m, read_reg(dh, m)); +int test_device(usb_dev_handle* dh) +{ + TEST(INTC_ISR); + TEST(INTC_IMR); + TEST(INTC_IMSR); + TEST(INTC_IMCR); + TEST(INTC_IPR); + + fprintf(stderr, "\n"); + TEST(RTC_RCR); + TEST(RTC_RSR); + TEST(RTC_RSAR); + TEST(RTC_RGR); + TEST(RTC_HCR); + TEST(RTC_RCR); + TEST(RTC_HWFCR); + TEST(RTC_HRCR); + TEST(RTC_HWCR); + TEST(RTC_HWSR); + + fprintf(stderr, "\n"); + TEST(GPIO_PXPIN(0)); + TEST(GPIO_PXPIN(1)); + TEST(GPIO_PXPIN(2)); + TEST(GPIO_PXPIN(3)); + return 0; +} + +void jzconnect(int address, unsigned char* buf, int len, int func) +{ + struct usb_bus *bus; + struct usb_device *tmp_dev; + struct usb_device *dev = NULL; + usb_dev_handle *dh; + int err; + + fprintf(stderr,"[INFO] Searching for device...\n"); + + usb_init(); + if(usb_find_busses() < 0) + { + fprintf(stderr, "[ERR] Could not find any USB busses.\n"); + return; + } + + if (usb_find_devices() < 0) + { + fprintf(stderr, "[ERR] USB devices not found(nor hubs!).\n"); + return; + } + + for (bus = usb_get_busses(); bus; bus = bus->next) + { + for (tmp_dev = bus->devices; tmp_dev; tmp_dev = tmp_dev->next) + { + //printf("Found Vendor %04x Product %04x\n",tmp_dev->descriptor.idVendor, tmp_dev->descriptor.idProduct); + if (tmp_dev->descriptor.idVendor == VID && + tmp_dev->descriptor.idProduct == PID) + { + dev = tmp_dev; + goto found; + + } + } + } + + if (dev == NULL) + { + fprintf(stderr, "[ERR] Device not found.\n"); + fprintf(stderr, "[ERR] Ensure your device is in USB boot mode and run usbtool again.\n"); + return; + } + +found: + if ( (dh = usb_open(dev)) == NULL) + { + fprintf(stderr,"[ERR] Unable to open device.\n"); + return; + } + + err = usb_set_configuration(dh, 1); + + if (err < 0) + { + fprintf(stderr, "[ERR] usb_set_configuration failed (%d, %s)\n", err, usb_strerror()); + usb_close(dh); + return; + } + + /* "must be called" written in the libusb documentation */ + err = usb_claim_interface(dh, 0); + if (err < 0) + { + fprintf(stderr, "[ERR] Unable to claim interface (%d, %s)\n", err, usb_strerror()); + usb_close(dh); + return; + } + + fprintf(stderr,"[INFO] Found device, uploading application.\n"); + + /* Now we can transfer the application to the device. */ + + switch(func) + { + case 1: + err = upload_app(dh, address, buf, len); + break; + case 2: + err = read_data(dh, address, buf, len); + break; + case 3: + err = test_device(dh); + break; + } + + /* release claimed interface */ + usb_release_interface(dh, 0); + + usb_close(dh); +} + +int filesize(FILE* fd) +{ + int tmp; + tmp = fseek(fd, 0, SEEK_END); + fseek(fd, 0, SEEK_SET); + return tmp; +} + +void print_usage(void) +{ +#ifdef _WIN32 + fprintf(stderr, "Usage: usbtool.exe [CMD] [FILE] [ADDRESS] [LEN]\n"); +#else + fprintf(stderr, "Usage: usbtool [CMD] [FILE] [ADDRESS] [LEN]\n"); +#endif + fprintf(stderr, "\t[ADDRESS] has to be in 0xHEXADECIMAL format\n"); + fprintf(stderr, "\t[CMD]:\n\t\t1 -> upload file to specified address and boot from it\n\t\t2 -> read data from [ADDRESS] with length [LEN] to [FILE]\n"); + fprintf(stderr, "\t\t3 -> read device status\n"); +#ifdef _WIN32 + fprintf(stderr, "\nExample:\n\t usbtool.exe 1 fw.bin 0x80000000"); + fprintf(stderr, "\n\t usbtool.exe 2 save.bin 0x81000000 1024"); +#else + fprintf(stderr, "\nExample:\n\t usbtool 1 fw.bin 0x80000000"); + fprintf(stderr, "\n\t usbtool 2 save.bin 0x81000000 1024"); +#endif +} + +int main(int argc, char* argv[]) +{ + unsigned char* buf; + int n, len, address, cmd=0; + FILE* fd; + + fprintf(stderr, "USBtool v" VERSION " - (C) 2008 Maurus Cuelenaere\n"); + fprintf(stderr, "This is free software; see the source for copying conditions. There is NO\n"); + fprintf(stderr, "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"); + + if(argc > 1) + sscanf(argv[1], "%d", &cmd); + switch(cmd) + { + case 1: + if (sscanf(argv[3], "0x%x", &address) <= 0) + { + print_usage(); + return -1; + } + + fd = fopen(argv[2], "rb"); + if (fd < 0) + { + fprintf(stderr, "[ERR] Could not open %s\n", argv[2]); + return 4; + } + + len = filesize(fd); + + if (len > MAX_FIRMWARESIZE) + { + fprintf(stderr, "[ERR] Firmware file too big\n"); + fclose(fd); + return 5; + } + + buf = malloc(len); + if (buf == NULL) + { + fprintf(stderr, "[ERR] Could not allocate memory.\n"); + fclose(fd); + return 6; + } + + n = fread(buf, 1, len, fd); + if (n != len) + { + fprintf(stderr, "[ERR] Short read.\n"); + fclose(fd); + return 7; + } + fclose(fd); + + jzconnect(address, buf, len, 1); + break; + case 2: + if (sscanf(argv[3], "0x%x", &address) <= 0) + { + print_usage(); + return -1; + } + + fd = fopen(argv[2], "wb"); + if (fd < 0) + { + fprintf(stderr, "[ERR] Could not open %s\n", argv[2]); + return 4; + } + + sscanf(argv[4], "%d", &len); + + buf = malloc(len); + if (buf == NULL) + { + fprintf(stderr, "[ERR] Could not allocate memory.\n"); + fclose(fd); + return 6; + } + + jzconnect(address, buf, len, 2); + + n = fwrite(buf, 1, len, fd); + if (n != len) + { + fprintf(stderr, "[ERR] Short write.\n"); + fclose(fd); + return 7; + } + fclose(fd); + break; + case 3: + jzconnect(address, NULL, 0, 3); + break; + default: + print_usage(); + return 1; + break; + } + + return 0; +} diff --git a/utils/jz4740_usbtool/windows_driver/jz4740_usbtool.cat b/utils/jz4740_usbtool/windows_driver/jz4740_usbtool.cat new file mode 100755 index 0000000000..2ef39c526e --- /dev/null +++ b/utils/jz4740_usbtool/windows_driver/jz4740_usbtool.cat @@ -0,0 +1,3 @@ +This file will contain the digital signature of the files to be installed +on the system. +This file will be provided by Microsoft upon certification of your drivers. diff --git a/utils/jz4740_usbtool/windows_driver/jz4740_usbtool.inf b/utils/jz4740_usbtool/windows_driver/jz4740_usbtool.inf new file mode 100755 index 0000000000..1ccae7d0e2 --- /dev/null +++ b/utils/jz4740_usbtool/windows_driver/jz4740_usbtool.inf @@ -0,0 +1,136 @@ +[Version] +Signature = "$Chicago$" +provider = %manufacturer% +DriverVer = 03/20/2007,0.1.12.1 +CatalogFile = jz4740_usbtool.cat +CatalogFile.NT = jz4740_usbtool.cat +CatalogFile.NTAMD64 = jz4740_usbtool_x64.cat + +Class = LibUsbDevices +ClassGUID = {EB781AAF-9C70-4523-A5DF-642A87ECA567} + +[ClassInstall] +AddReg=libusb_class_install_add_reg + +[ClassInstall32] +AddReg=libusb_class_install_add_reg + +[libusb_class_install_add_reg] +HKR,,,,"LibUSB-Win32 Devices" +HKR,,Icon,,"-20" + +[Manufacturer] +%manufacturer%=Devices,NT,NTAMD64 + +;-------------------------------------------------------------------------- +; Files +;-------------------------------------------------------------------------- + +[SourceDisksNames] +1 = "Libusb-Win32 Driver Installation Disk",, + +[SourceDisksFiles] +libusb0.sys = 1,, +libusb0.dll = 1,, +libusb0_x64.sys = 1,, +libusb0_x64.dll = 1,, + +[DestinationDirs] +libusb_files_sys = 10,system32\drivers +libusb_files_sys_x64 = 10,system32\drivers +libusb_files_dll = 10,system32 +libusb_files_dll_wow64 = 10,syswow64 +libusb_files_dll_x64 = 10,system32 + +[libusb_files_sys] +libusb0.sys + +[libusb_files_sys_x64] +libusb0.sys,libusb0_x64.sys + +[libusb_files_dll] +libusb0.dll + +[libusb_files_dll_wow64] +libusb0.dll + +[libusb_files_dll_x64] +libusb0.dll,libusb0_x64.dll + +;-------------------------------------------------------------------------- +; Device driver +;-------------------------------------------------------------------------- + +[LIBUSB_DEV] +CopyFiles = libusb_files_sys, libusb_files_dll +AddReg = libusb_add_reg + +[LIBUSB_DEV.NT] +CopyFiles = libusb_files_sys, libusb_files_dll + +[LIBUSB_DEV.NTAMD64] +CopyFiles = libusb_files_sys_x64, libusb_files_dll_wow64, libusb_files_dll_x64 + +[LIBUSB_DEV.HW] +DelReg = libusb_del_reg_hw +AddReg = libusb_add_reg_hw + +[LIBUSB_DEV.NT.HW] +DelReg = libusb_del_reg_hw +AddReg = libusb_add_reg_hw + +[LIBUSB_DEV.NTAMD64.HW] +DelReg = libusb_del_reg_hw +AddReg = libusb_add_reg_hw + +[LIBUSB_DEV.NT.Services] +AddService = libusb0, 0x00000002, libusb_add_service + +[LIBUSB_DEV.NTAMD64.Services] +AddService = libusb0, 0x00000002, libusb_add_service + +[libusb_add_reg] +HKR,,DevLoader,,*ntkern +HKR,,NTMPDriver,,libusb0.sys + +; Older versions of this .inf file installed filter drivers. They are not +; needed any more and must be removed +[libusb_del_reg_hw] +HKR,,LowerFilters +HKR,,UpperFilters + +; Device properties +[libusb_add_reg_hw] +HKR,,SurpriseRemovalOK, 0x00010001, 1 + +;-------------------------------------------------------------------------- +; Services +;-------------------------------------------------------------------------- + +[libusb_add_service] +DisplayName = "LibUsb-Win32 - Kernel Driver 03/20/2007, 0.1.12.1" +ServiceType = 1 +StartType = 3 +ErrorControl = 0 +ServiceBinary = %12%\libusb0.sys + +;-------------------------------------------------------------------------- +; Devices +;-------------------------------------------------------------------------- + +[Devices] +"Jz4740 USB Boot Device (Rockbox USBtool)"=LIBUSB_DEV, USB\VID_601a&PID_4740 + +[Devices.NT] +"Jz4740 USB Boot Device (Rockbox USBtool)"=LIBUSB_DEV, USB\VID_601a&PID_4740 + +[Devices.NTAMD64] +"Jz4740 USB Boot Device (Rockbox USBtool)"=LIBUSB_DEV, USB\VID_601a&PID_4740 + + +;-------------------------------------------------------------------------- +; Strings +;-------------------------------------------------------------------------- + +[Strings] +manufacturer = "Ingenic" diff --git a/utils/jz4740_usbtool/windows_driver/jz4740_usbtool_x64.cat b/utils/jz4740_usbtool/windows_driver/jz4740_usbtool_x64.cat new file mode 100755 index 0000000000..2ef39c526e --- /dev/null +++ b/utils/jz4740_usbtool/windows_driver/jz4740_usbtool_x64.cat @@ -0,0 +1,3 @@ +This file will contain the digital signature of the files to be installed +on the system. +This file will be provided by Microsoft upon certification of your drivers. diff --git a/utils/jz4740_usbtool/windows_driver/libusb0.dll b/utils/jz4740_usbtool/windows_driver/libusb0.dll new file mode 100755 index 0000000000000000000000000000000000000000..9387bedad1d4ec91bfb903486d1ed37abccab63e GIT binary patch literal 43520 zcmeIb3w)Ht)j$3utP(J=5rf8xy4s+i1b34SxracqTq-w#09IniWdo@piM!8oQNZA4 zmF?p~s$gv^7QFPe)we~9xCsaWQbLsaMoKLTDk9crO{x(n;-%#GJ!hV0Zv^%2@Am)v z{;p1*XJ*cvIp@roGiT1sE>nNpB=wUd$$-?`D@lGl=~KXezxhuCss~@&GFaL=;Lq3j zW2XH1y4j1Wou+z6-9ks%VpBy~ZEc-wDz}>)u3A%dt*L1GEYsq;O8e+Rg9avRsAt$D zX-Z6-ROj!-oA?})2LJGqnAl9I3i;n45pfAxYQR%kP|NvPQ5Ay{0udkNknyjHVZJ2E zB-&B~!hsJzS|#b~i;(G*q|AYM9+RXd5=8W;N0O2V?tk%Tv}|7{1LvVi{2_vf*ANrP zfJ^*8y0T0z!}}JhYe2df=_g2Gp8`p09qkZ+^}|rngmev3JyO`G0K+=E-07qu=5 zhO^hy0gz?hgG%c6=`bL?7D&?g$dd1K|E>gzy&uk^TsEu7p0?gAHWD^{T@rJ=ZtZEt7ngVhcZ;!vY^&;P_`*oC*ZAXP*eEF z-DSx7i{nbApQlwm)!QkcxzO3=lW&l`iOK4+1(IYr=w(FhhGb$zosBY2uPZ@E@0wsa z!|**m`{_IGEG^j+FHs)w4LbZ&Oi8O;(~c5JdWy(Ve>ET2Zor?w4ZXd+O@c_@63MsY zMgsZ{^jUh-z!<-hz|X;+R#v>( z#Ql}%_^9hRqPhvfn1<$_R@cCeK;sCIDCEaAR@4wd!?b7RD0CFKlc2WV5Y7+v*M4WP z82$TfJ*+~*(7xT)O~7jLaO%jo=4M!9C67q*^vd@^>`FdQQXn?zUm1+k3sPp01sOgs%G|^~w7oP1gj)MT1JlUcJ49rjMu9 zyH`$c$081t^>NAraabMO3lk~dUYNkeg@*RRczy#7saKF>y>BlY;BHIscHVI(xd7WgWJ2}EUhp(Fh+z=%o1y|x)d~n)IG*E zFQBpeY`>PTP-0yB6mrI$8@kZkxYP47VL@ZBHF@{(xB;Dn0Ti`xhqIFjqd^^|p<4En zhF1b;AW*sH8+S4lEgzyjYwvwiEC=0R#Wq8P(yClA>8tPUN}&0&&yYRVy*qY%)@!Sh zv))`~YS=N7&`7So8@Dx%Bt}rX#*htw``&}T172F)Mr@LZF|<+k5%UM8!CP`xDT(vC zzNQhl5~GTzcb{5%2i|%VRHCLEQ+kO6c$kn9r66u^6VZb_)B)Byj+*8tV1(QwKsJfo zM9oX$=G{>e7>ZXNUQE_@n+oP6^)-mn3;o6%%caR$+>QB6q9V(D?m97zhf@vak)M=` z=Fn<1WqdTBufXIeKB3L$W0CV&DLxjQ(uDEoj~QcQ7Z60u=T}kit@C*>MyJ=NDl1O} z=d)ZJF+XTxW)L%Hfe*9reCq%X#mrLfXKnzyn_&BUm+1xsta_PM<-u!+;Z}JGdi8#e zPJfNNA8BS}OOvh%cI$s-!9O8fgxg*`Wh=uv0rKs>sOpI)C?=<{xU|6cf`BDjFm6*Cty+O z*xTX122Y`n%Fs*zamDH{kKK8;ch!3&u8V-XgZ0;s?%19rJw@nzws?&mTBE2drb!qP zgZj=qN!n}$oTqiwL?)&AM)XBMoBapzf_2p0T0l~Hm_Vsa%MU>wI0?Lk5n~Be{{abu z4on<HVWhv|?#?uBgTZ&fEDiIn{90L=w8nM{MTy>$(@IIaS5A&wV><~;o}0Y- zwFW{#mUkw22hb@{Ehi_5Wd%$aw-uk04< z0lHnu)-WWm5Iu>49uQ*ORuT`gK*b6yBv#UOgZla$qM`VdpBJ^F8Ez6X#;7e@q z&2Ab>Q%#wAOo<_u%E6L%w_-cy>F~xG8^?oR09$%B@WiH=H@s6j0bbx82XD4h=wO_` zS`(o925hlX+zCEM+K$HTi?JPYuRI##bsboBPiTLFR=%k{ekV1eeE@0kV`vEV?rHcc z#`wSt&}-Z_^|LkmM;UTsjF0YV_#zftvjLsY#<(s&*C7vqa!-ueM_q^x?t31tc#=CW z873mexNd$Vzur?fmmDy99*30%&Fuv&?Dhg40HVd#vz=+dK+%|~@t}psUNsPN`?GWV zb7PidFjGPcsxgrpTaBIu!Z)?EecS*V2Q-LVmC&#%#^4&*u&SSA^laee^AN_%doczg za5et${5EdeJ%ROZi6*vi^ZM(V#Cyp}uqc#+G-1`f+JxLiUHPV-B)K(f0>nVX)8G|j zQPo=J*iIPNZAX7B&KL0lah~c+oYyye5hGt6lw289A3aY9b$#E@uq|%9heV=@ckN4+ra9r1cBB3VPwP<88^t-I0}M;fXOcMM$rIPq0`#_#rAueLJDPlQ1JQ(H=SD zwiyO&_;o-GGn+_*`Uv3LZHGyw=u}KUE3mfPwhB2%Dk*eD?fH^Awe{rKjvCiJMuUO< zpRH3V-l|L*z$zW{s&DEi-s1hbYE!EgZdLLLM9U2`u@(W#r@0py8}|T-F4}dp1GKb4 zt7GFA zIOBtbK-%!t#l{Es;icW?M{7x0c@$iGZ99DN7kj6+jciA>#XGh2z7(aT?dB3pqg!Yi z+4i>=@HEn9r()Yd^X3!=Bd{HM?X!KtGe(=I2Bo--EOq%8tn#0*n$s2mYW`_oYCf6N zyl6Ao2Y6k{n1L6ZfY*Q}OruYFZGM`A?J>5t7~2kt5v^N7a<%!%0_T&Y^a)`>hQ+&! zW`r`;PZ~~wCF=$$y*3R}qE*Gxiiri4hldNZF9uaLt{a5GLu^2oJfzV)`e(usBr-{Z zmYo%x2A+XPXli8ur&7G1W(qX@AsSYmDXscU`3(U~-S549P~i7yqw#KBdj&EyB0%iV zq+Vct!wt|iXvc~WI0;=t7npZ(Ew>XSCLqU$$o=py=%elNsbJJc++59~KEm4f7$CWa z=1d|JLTO>`13F#%-aMdZ*JWW` z`?zSV>W!OkxR5+Lrl9d+YCMRg&|zF#DjFLf)`Zz|88yb(=p+PLeux^I0Uo6KhobEd z^|rePQ(KJUPHrTJ24V)aJ&pZyuhtKW zH29r7O6}t=1(+0A5{2gRAeu23LbHL;*y6N>T`0^gKtuaQ_V-4Szh~=F9^(!05v*$9 zUW@J-w>4c2`_YIfTrrojbJcYj!eqv6d)&4|Lv!%9HVbtMtn*=5dpKF14*6Zpp`%5n z@t`X)Kv4k9Z?ww6-?c}PRZ3Lfu(y zVIyou-L}I+mEsdwGYqSiDaA*XSf%8!FE>ejw@qDuy#%YTp+`fxHCwz-B0s6$f#W%bFVf_88aQ1$bKJvDhh(5|hHe+6&~`qPHp= z>*$YR7p_D9!R3RtxmOYT2ut|&L|wCe?7!0TH4kOISXOO*s0a^Rj%|l=-DhN=AHbiL zZv%Ipj(ZpA;S(I)_#m9fope1Jv{N(C3T@`=ZFErcdGyqv@4$5c*O!=8qcNq{yeI(U z{VaRpph=T$kUt2ucLLOc2cAUyGvq8C-nAs7!0TbF(@~Jp7EQ`c=aKS0+IMZyjr^+N zp4MeENCm`l$^B~gr9eEUR#NB=NtQLZoo$l5+-%DEj%|LF--9(-> z*`KgpXr(#>1u#JK_mN+VFbU%8jj*xPl2NW=n#QqV)~)t>|_+tpS75JD1A^TMEtf>4{$ zehq50eZkFC@iF0E6CN)Zh64($A8_2`SDzbcx?b`YcdxN^VQ0Gf+*D+7h)7#hd0@lJ zF3Gs26TGcHH<~K|G4nhK@9#;fhU8p4)P+UhcQ3-P2s|el8>#AROKY;NJlG>u=1l!EEjRwS>s-^ zVh0N`@Vy&;`zy%ZVkj-R{FV@B_ZVg7P?ht#N+I1?fdjvkU$ghw|H$YqSSf+55kuX219hc7hq1`}5V|Srzz*B+*@M(FaDYi zP!@48GO3yNU|0)%CHt`udf)TfTIr+Zl>D()vF?D8T5WFL1|kbrPR#2a8XvGl!u$?rsv^ZDezTtE$h| z1}FgYYVow! zCIbXk`EQ)AI0he+>fNvY1cnAo#Cx5ImR5IL0Ua!=!!cykh_=(fjzLIzRGStbe*`5d zMm=C@=HM7o%*+LVP!FJ1Oq#7|^gIVeRF>Vw~3>io(}ye=@w z##ZnZ$uzb)jJw7q**`T$6(&?8EBWUjt3R>mKt%+L zLV)0^hG0JUyUyqfDB3|qox!3fyl2ABE8N|QG<-1lXM5!_%B%#>!DUAFC*$bGEBFI#>E@aL~_fekt3*4gldq{t^^Ig6|Gh8WPi~iDB%+h`sRWc8mc^Kz@BxNjInl)Vn zBd7f1v55yRC+oeXJYrxxc)`_@EVwcW?5B6~Ba` zD>>}#*?smRZ}B1bv3_3L0YZ7L7qL)Wr?4IM_9Qpt#$0*C{lV9(_gWzj@5#o4%kBno z?pD-qr9pP)@CK#b*!UjsBJAbuuK*8@yK%HI5sSzn??fy=hrJWAQ90_Jn5Yz+d=rys zjZ=#00F4ZU`UJizAW$fB8_DOA4=C> zv^GF)>Yv}o9%my~6mJRQ#!1_GF)BU~I6^xTThjIf5|-^i;57z0u$?AzU?(!$!0jKf$e>^b6}*lD_74M3 zpj4l~u>Sy{Lu$1IC}`U%7h!~(sfZ7S`M#KX43+JLapf*&3hrRgpj2UdVkQ^pdBQG1 zxU{KFqIEhE2i~YSKoxWKZo57z#wzvUT;5aCzGpsq@OpND81E}|{h%uyZN8>9KSUea zY(0m#CGBo5gQmegL015_nt^-CF04CC>dU1qbhO=U`4#2|h8*|%HmHOcMt^%I71F*N zM}sf5Q7QZm^;%*GvLena&<}BrvqWG)&weVloB<$?ED%=!yXw0DGH%;IBoL!+y6|CX zUGvBd#D>1T!b`;F3aan(FeUIqc&C8rHyb*N{S{VR?>=MW#psf}hGsk=k51r+oIHo{ z^s|@b*^gJBN2lCBgy0CVJ6?1h=4LRgcf(<{XkoR(T_M!-cP|Y-2Q2(Hk|McCP__>;P>*rB7cx{{q7lUCz|p)_ z5yRQfI}a{`0d!(6#(6jL81w#@G>4YqdBCO~co!;qBM8y#KMlDbVaC8^q{qAnb@>6j zf`E+xX7$zgQP`p=8yGV@gRTI@uY@-Y6{CIg9Nw~NdS*ESe&T(vkSNJ-7RNBq1DIc; z=XvTP7hQBEBX@{$PrL(AF!?CP9qbjZ{z~W^nPQ+wXePaCVU2^!&sSfdF))!}(Lhpq z1+0*DXWvZhzEKse9>Q}Y_&n}NsD<1l2D~K+oHWxPG)>TAPo&{3lgKde=%ROZ+$pl8 z#>TPm*u)rLVSFGJ8E_*#PG=)9IEP@;m68MAL5YnR%b`j5`_wRcB{|SI)3M3b2~+|R zsVNXZyKO)E7T0E4iiD+NiZA52?`N9S7Z9<6WxtFBSPX4}0QGSLMWaBGntv41elPrd zmE(`|_|^r*AL-fy;(!y$H8nQ=iDck9VCk?N0Z}wD*g7Q$;ml8tqm3H5*ttX{MQxx> zH!&HmG3saN3~cHS{%j)Pl_QuGBfuo>%=YLzv(Miyp<60sAJMh8wM(${@<_1cGpPeQ zjw5lQlRqJVC+@&RZSmB5BYS-ay>_hu|9hB!bT5J(`$PT@T#F*|8%pAZ>ma)jyT-He;d&5CuzNm#`wnj>8*kG_RQ?i` zg2tEh`0ykmkKG!%Orz*q_B;h7FW&R~sz;O5MRYx=NxehRL$nl7cQ+F)kD{=HC;h8zCc(K@)sCnISZZ_w!7L3I#8@(VTrN6}2!15CH|&v=|$O+puAU zg3yhsph1|AfQn}K_sX;Wy{UCro%1PAt?NnkzD$dlS`${EV;i+L4>P|j0O|2eJ9HSi z&MH2SvGkJr8jpyY@<0OQL`H-5FCwQj(P1vaLY^_Oa{C%?L{3s3rKPUR*rdS>ImhLm zgRW1MCkTgeo0|Z4AB)8>tCw3K623R8H5{U~Yara-M87g*BHDiJZo{^RyD~O_aIcq z>~j-o1NONu#RGLi#N#qN3ii2wAaYlU$1w5W^MNX_doZ$oiOf8+hms_e2rjC;kI0NmM z_U4Rc-ViP0uu?+M^7wEjEF)NQ23_c8E>4|*I4ex;4~3kxDBWgA3wQPD!f)6uH}&Jc zX$Am`F{Hkq^ncr%m~_`cMZEhgt)IUOksCB5^ZP`CcG44=EEIiIm!ok+$0Pb|qs7RfwY4+np9MTB3vOC`#I=tqNlapb{677 z*w)zi2tBbLYJ1t=LWRJ0UMxmWp6#=p6cXf7Cuyo;eJOor_XZcQV2sJ5eX zk^y>NM8y33uV6D4azi!69bx{kE4v)kk5Tn9RMWQjAxHy3$-^og^LM?E>Mc}#yH-uY z>geOXHn3q=OUz&wT@v^Kz+h-Y@flGMW<>p$q)g%U;{LTVm7H52P6AgZwA*?Zohy;n zC)~?G2i;VHtU>)P0!IkP-NozM>T{SUlK0fAi?;I%7E#2y$?>Ckyc1zG%*H*-CeX%( zv;uV~uL6x+K03zMJ#t@6JMJm{x;5)qBk1 z7vGmDZlV1;ZPMf0ZG6-LcD+;MN&?rT57?^~4)*s^AFI`0sQq!s>6_Z`5%uD}JDVJ% zBB_YD^S0x3XKybqy6?q$0)4}GFt8^|*6I~DE6{)|6y5=-FKdl%`Lk$5oc|FBwCcyS z>I787+u6#2?$G!`SK-G(0S9!j^NMdGsh$JSxCXQf7U|!|(bl);u_j@CgN}8Qj=4tj zB0!cr20k|k*m)G?SYB(&^@Cb_0usQzMXh@2Zzzu6c z4V$TtZG}(@7=}Xgjn5EyI4~r6@JJ^5 zJZl6u(HsyK+!+TZL+{WjjA9tXGoj%XY9RSG(nHQb`~@D#{t>`CELr0MP1Jpm7kczG zP>+C^fYaER!@hYj4a;IA*J~4rI-Sr+B0YD|5cUutCsuhAftyaWukiw^%1})`AG+w z2ND|?Y@cVDXwADa3NO%hAW}xg#%qAW?ITE&XwbrnME)cpn#gppeEBOy%!|6^Bki|X&v6zCn^*c34A!26@cYiZpNmuNmyiOu`U`VLOZr4YxD$Hu zROgE%ZkSjt^kPVEnT<+X(N!M-GytHv0!8G_z%Xs57SvxI)z%}^Qm@sbO|bShs%>TD zaefbB#K;6|)2OyUt9>lGb|}?u(Q5xAy7qG@_*0v-+Lxkh-=f+kt#)s8?RKhNpw+$^ zUAvKLXP{OY)F5DRY>e;35|i+lZc_%e(p!f-Q5jkw%JP&!L@3JAl%bnM*+^v&5rDF5 zm7xnn*-)B*E1*vi;}?|2sT+9(!N{l}3U`@=Jw@KS86&kG3ljNfVm!H3*m%-lyeJT8 zBdmWvLF~ue-Sf3bxq8O{HU*7-sJ{9x3^I{585W4|uagq|5E*ofda3y?^u2woWTXui zkA3gZ2C#$O3sz(V&hCc^$Am%T&nWrt0Wh>in}H-U0k>B+@w_JCXo~g_wHrp}P%Arw z14gzyBCpc-9M%8AQIq;AnUH5L4>uv8?tb*emc*b2hO@s(R(G#_3$O|c!++!SRnMTl z$Y69-d78NW3%md#=7@{V=Ri&aqU9WJOxQ&XZ{I}RP>2E1DVl`pr7U2qO2$Uon5Y(_ zZWK}1Kbks{ou9=98|Nn>3ab<$yBmQ7JYz2l@e&-%kF8g@?CK#qoOqCl#*)h7;U)D3 zGx>Y?LDC~hr=da4CkA|u%sk(})-=Jzg(Y{nv z$L(SXqi3Lbmf-RM7x)@;Qk|`V1P1{iDuG-@Ah!Wa`2I3~l{o~tC?0AMu{&&PVP~M#xA8FH!erXj z52#r$*|j@*9XbLBBFsuFB0234O`=|+yAGzOSnD`EwvAf7)JcqX;o3MXM@kFC+Uwmw z6sRBJri~g)Waafu7KA}6-ApRo!s<*5EsTA*IlxiY`$S7_m`cwSL;x#y0<0K$;L}1H;78FrL9l`aLP_YR7zhYio)YDDXk{GG%xX+JAloL{FN>@Nd(s<9pG@3ZO%QBPX5 zgNo1YL-7mh-4JqKGJFfy2C|mmjSer&cv4tu6d2QZ9H9?Ykhjp_`N6vh;PIk!IXM~J znjmVr) zgVF1potbDd%UAO3>h2YTFaq!S>rs5_8N%#)B@-R_>j9zBp^m>6dWl1l^@#8K*VB-B z9>XiVPW&Yka4F=$=AKne`)=GTkE0gf{P-yv_>XDmXv>KPt-wfJF}z%cK4EjBzF$q& z*e^lIIvF=}Bl#*a(G(3lf*(qOBK%Frn5lz~sL23RULjiP>&{!zyX7FPk@h8S<)uwj zgD?9m0-GSG`8bgV<3@Cih@h*(w=oluerrt#Q zb!4RLNw^btwOGN714_=7a`^NGm zSAK12^}X^Kdf>ZYxC@A=kw^kFd%3Eoz>m=swU#*nFX~I)Tj1hh=2+`6HwP5P-8}o`sE%9zjYlD0Rqk6_JG5V z&pUUk*XkGRg7U=qtGhdsPE|^h_=F{nPh0S1+a8vwnC9xKt01FuLyQm7-KO5;mva9D z+b{aQm1^nGJ+efhR3fB?V}3e8V(&|QD-M1D3xf`CC{9PW4>3a6EYS}FB>M2Jco-Vt zC*dnN5CiF(dOMF!5*CSp?v*{U#s@zjuAxso&>s@cHsp2vz?HPfJ9W6=zx_80YIXk; z-w+_7aeR^7hg@hn*hJ?6c>8xc~m8dtZNb4~oI(GTaqUoTsOa}NXrf`9NJbbQeQ32E zD#^4Cz^s}Pu7nsS+=gk$k-9D==4SjLY}b#Qx;dj<>b`zb*9W?*8d`=}DdP2Y3h}Xs zz9ZF&Xm$7YGp>CWqQx*K644YM(E~9Y(bSZyo7B1+%4PKYnZQBTFStl}H2iZ1>dWw) zAR!vhFbM_TqPb2hYlk>?gtlK;D*W>y2$y1**I<}Qbn5h7G*ttOfrkRA8c8F$fA* zi!bzp8S>Q)`P%qwfd>|f%KT&GDPLiXyDfpQPzLV{^8Hvo!1xQKu<~oRi?lz07v3rC z$*JdHj^iL*xZ}Ivbt7hYfG#Yw+YXWT|3do4rG4v&lg0(3K4O zbBX>WqCa|`hpm4Y6Ef}8Meoo|wC736dp}nPD%Jo=S98#Rrb`3(=Bq7^J-d>?NSb>= z{^<8m^m?MUBrxED^<-H}&hu}y?>ntTKwE_2@yk~(+zI0dym|+mJ}{SI+}6+gHYWGz zhI?bA(D(WAeVKmyVn>Y^Gyl?tdk`PvgAdJq3%iw|&zPX~q)0GrB3aKq!a(vNiOcLh z7kghGCI#j#2jq8f6_m|26ciByk@f^&s2huzy}kyizZD+)I1G_CL2=lLezd;BkgsFp zNnM-CHyFPQ-3|Kq|P_Q4Gn(ts%QZ%z z4iwRt>Eu6&?x_671iF_^IgI^2d{0@kDf;+p=T|G~6a=m&a2Qlt58;Zp%gdwuZ*5L_ z_cmloT{l#5y!kA8@>!F7cgB#YKBg^XagT3yLX5Y#2R{lRx#+r~dXVVJO{S`%%oys0 zycM;Jz(XDHfN`acU610-iizfUYPfx%^B^3(V65a}-2Y+hv8m^Jpb81~Lpnaf@7?fe z1N|rrT^b7eZ7TGMh%r=`CLsxqb|J+3?Pu6RT#2gvWd5#fCiAztjV~S1O%CddzkUQ? zH0HP3+VV$UzFlvk(tojDNVohvVnZwM>}r8p7V`$5f21ai9^AJkVn_~x5cG{b4*UOV z$3LlmXyPSNH1t4L)SXf9j($miAdMULgn>rPm*VEj2^uba@0^|F(?goM@aC~z`&|1$ z1db~CfQdFgpaKw@D~}~hgxKx^usF|%^wm>%ev5U4<98t0Jh5+J*WW<6I8z97w;>NSi| z{wdj=nQ-FpRG1~6SjTwj6?^Q+8v4dFwRsm)51@1-P<*FL5X-n9#`mfMDX>eMO^{UJ z4Nyz^f>x?%9oEwlt*0Bwb%>xLUh7HjyC?Et)DhHEH%UX+Q8q+jiVBG@AhkTV6{FSK zrGgNBf2ZpwMoMg#=hGS=QYY(FImr2V@+ybXw0Se(o&wCO?4=3=?P~4}_$< zXdiuoIzRA7me_B@*2}rx_Bq}+EeA1|<2`4TB>7Sr)Ta=FvK-8#=;xAa-EHw&q=p1S z-)TcnWr%#Dr()$Q1o1yY2XTN^uR>;4ph#VVtC|%4X3hgRUh^J?kbA_J(y+p6YZts8agd|y zhc^FL;K*G4FTO@5PF%G4Pd}4@kc)2%p6VaCzGcMkU>P<%h7#8${uz|mH(R^1pgHUz<{Tjkh2z2lnqG7 zW7hFdHu{(#m99s#6m?HnOnf4miSoTfH;J)!d7ehsT*TMJ*~AgXEr^I=tmAO7FKE*u z%DlPNZVLFgF%bl_M^I2(QZ6ghkH6z*^lT@q2XuGi`;c2SVfyqxp^qVsL^6WMI7<5VB9{I-wBSEXU?dRpTPB%7h^Fk<`* zBT$|OU{G_n(0mO10zwV*2UmALPWpMvKWHS4jjuxjntnb6oR%{X`b&IMVdHw_)&30E zOnTa~fR-_FDPsej?Yl15RF-a9_($*}N9Br#{#tt7@FT$!WhN?CKZ5p)6~2{0qwoY| zfG-AfEh=dg6cqUk{aA2I+l4^1DGU<<|MTjiVCBC)Ly^IjMtKN}DX zHVHIctZ~BT1QF~aTLaV&e!>{zMH9%J&{MP5*}%GN-r*}BrwhGVFMXK;T-I@x| zS4QQFqVnV!gu_$NG(1m%?eIKZ%?Zy_ATc~o0rc=Z1^dGD6d(%EQ@|&b7xC}S4VdSc z+42>=3AjmtjB=a7H_q@Bz2f3=AozWAz+*8rY;Kh)*4HbKN*3- zH`GAP_dMO(dpmYvh_B|gp-So+SfC8^&@23a(_K3w{38v&a`iEsnxQ_OdlENN2T>Vy zn#`RJrv1zL{S8Eaw3UqLFH!V&5dDS!nkIfvqPhNg7{Cv^5(OFHo2Fn~%>9zIpmy~a zRO|Q{8&my0;pQ2CB={0#lA-r~@0sG3@z4_p#rSfoyStK>17Gp8u(z{$UBV3js8b6L zq$K7+1ljs`<;8UTXxZR~6*oOQ&UJdgYsf7>>CTz$>hHz3O~m){4?#y;K1V~pfhg3> znR+j_7!YkH%C>(-Xt{Pi<_H!SwFI@%^5pydI{>QW5$!lu4gRh|yX~=Y_-x*SzI-bm zYqvd4*>>9|dU$RA&0A5?ZhKmkJ}XLhZ1!{M^P+T%C~e)mgG;xHY}@8mWbx(A&29WV zuz5c}J2xNT=ON?E7j@#T3Salflt&yBa$*@8DAs&8j5N5M4XV{I@J<76Y+Q#o*icKy zPO2b=$z4#F!L7nqr&=Aj_5=vJ^1fv;e(6O5x9$B1R2gcZ_rei)$FDOaZf>G=ZB~*p zbUnQk4%?i-^<*A;y|YZ-Li6UwXci28oa?QdO{n+I%EYg*&`V+NW-~V^5)BHxg_D$_ zPXl)ICTcKi1`oNnaEkZvb^H1E<&#Y@9fomh8gH6}CO=yK5zE}`q4P_Yve#2XuOwPr zKBZTZC$4$YE6dWej9yuso)z>eB-)@!v@s;nH9imZ0#RW_W4ZQV&U((c#>3M-=(>j7 zd^br#7d&bqdzIo5@R6=2HG$LqQ~^KZo?1Xp?WUZ!M~wqm)?x2S*9$mB{|XYXV}KC!*lhsQjU*e0Nm-KvaH26#m0e^`@x$qfzwjb+ zLsY&gD!(i$zaT0|`WX)M{rmqK2^7y7Us_}vUp!GmS6q8n zZQasZlilH{b4b(bw3jK9$1~)VDcPbV+cexcPzo=uuC1yQrQwv7moF`+kHmkqH_3Td zb$xwx?Lt$f-C5zNu9xc^CiAl4^9G6JuS~X^7TXusIhLEMAdDcH_%{R{Wswc#x;oS1vfAbN2NyNOB%Tny#f&gio04Bv zBRlP~%wh_**1JGsO{}8-2wZ*9R$Wz}lCQV^7CwR`VhGM-B#h?1`l+a^t*XX|_0e#) zE&>7La+Jx{b+t~@2q;xP24^Ign1+9u(q3EVTDZv62UMCohqt7~dZ zHTEibpj2F2R$gN_$#tw}Q6q@EBEjl!U?8N8BwDFZuoWr=_BxYuQJq6JjR>mn@XAr9 zh2TK&^3DB(P>~{pU>DlM=MV{pX`QpQuHIgo4Mh=(UR4cFYs(hfzpWmI z0enQ@s47F_N|F=d1VFZFDgHfBwlQQfqT%&EEA30FF)$4AS?rFmaWzx)|;M3_UUtBHg z^oSf&>9#}A5j0&u z7U#izGwmTo?^|9DdyT!!X)o*Cg z7GmGjbJcgD{lAIh8|gj|*LhTHdWvz37?Eft6qOLid8)_qfu5e%zKqt@3Rsne_DJJD z$^}FU9Ie> zt0`UVTo_VEEcdQjr>njmD*$Y$Zc@l8f$1c3#e6~xp|(!gG_r_VAzTNivkc4%+jyR4 zUa)VyGgwCI=sdXd**qWSeA6kY0KNqo3uW9pCYmY)>C|vWz(k|f=@qb=%LoaTyB5M9T4Jx! zkrJH_I{@tU;j^`@oSYbYy|&Pvr-qEbk9J&i;dT+dY2y`I7^$`brrS}v2+Kw|Ia~_g zqDICJ;DSU&w~y{1*n2o?L9qahW;3ioG_JZ@sjjL@j0xE-7Hu{ywPFNG(hF%`3u(ih zft&f%E|rZQTSuwS>*2B6i&&{A)H!Cy=anZmmI<RP7^H?UMprx7EwO{1~# zHL-U*+{vyH&vJ6+`-ZQnD`VpvqEwqV)Z|;*gp(U;)ptJ;bXC^b1#z?_lwm!i9ildp zx^bgD(l^lH3hrjui4R9VP%5ij0x71YvK*(wC7o3`wX7Cvj$@p}S-XQoIZi6%Wp|dy z7V>5Xg*A0fyH+-doqeg0yn4NiMxqAhL<5m#$z={%%Z!t5bJ-oswH#_>my>o;v>NL0 znp~Zt*HRjRQfLT`o<17bT8Ra=%2it-wu{)vhqI+yH!()vgsW)El!%tvf~QgA90&YM z?2=eLD)ku3EZfXElM8L7b0<$Lnm)I*aLTw@vq1N(x+-~TnZrJRYITL9&WYUoxmf?| zmOAGbx*QJdc;<*jVE#;3t=@yquUuD;y%I~Fcy%JrQ%@^1-8kHNqsA6*!=_Z17dy*S z&_Pr#o4KoshPJtJl znrOx%$4t;d65+RSHqL7pA(9l+t#(H(7CK>5Mwv9(N36e^S0Fi;J7xRgwAA^+R5*2a zVKgct>ERu$o##D=rmPUFRX^SG&!pm)?$ntb}2_HlPd9_9myn>OUv=MMyke}OLF3` zNs^^Hu5kdSOuCCp76HPEw<9Zs3ZLQs2=_JpE%u8u)J&lN#Gf|zs2i4brzTkD8)NCsSMQH&K z8V^l7SP67Z!TgdIRaau|lBMd!Fq#s!yVYgV;<`%vV(@Tp+L)?}Ec+O9N`-YydWywT zQI(QuP9KwEwOZ5D)6%VGd{zQ3!FDIZg1PcfUz%oSPYs`QM? zGJ-?x7<*PmYKlEAmGRkA%Bw0YDdtSGIkntwF{fEF32sbzWu>L6VoXY=#ayM~vsYy3 zaH;03)T$7^F%{p2PxL#c^4s9j&6SnuscE3TEVGRIwSd0#O7LMeSAp}Y^fd5WNbzB5 zYSlt4^!0Yfgz6duJe|^%x}~9vSiy@B!;>bJIV#DLPA-zB&7L|#Oko~>hkaqSQ+6yb z#o(3JJ1~J9@^UfwVyV^vOn2E4faPEohDC~HbNGU7fs1Ey-%TU=kM0-qnOzkfc@+QW(JYi6YXz2W zlAqo;_RUTwHrA-Xt_3l9gb``1!esfaxGK<;En_$?Y-qIMh-kmKOs-f|T3c6&pBQx# zA^NObr0IYOk$bJ-4U4NwB}ZMIOu*WrtT}uUIC%jSGZv0H`-S0{FErmHa5%7{F0pIP zv5zH%{SHW?a0v6nPU!h`^ub}|80+Tk0_`uv$E@3D&9+U|eU6}iCC}Gh=ksiwFI^CB zmheO1w$K31r+u^@_tn)46M*F-1e1-phaO&c*kwmGwwU5fh}4ig)d;!J++{s0rP^?* z_9c?Yw$MyWd2K+#`-K8y1rXN3ggCg%uKV?RDcg*``@N7TzhmEh^PGYsw~2*?bJJ2& zY?D&bQfB>V%8ybe&YmLRr%2(YN6Lg%uSkX``*9)9LLN;egyyot8P~7T`+}_)>sybOp7U zXqU&yb&IEACXX|XD8uV0lN0}oKAa;*ny$+;nF;dy&;QpYQ0MQp5sh!|7Iy${#yh1E zt&(&IsR8BnMfeS7E3R7NX`%ntV8qW3c9lTcj1cDjK zl!*3}@&SwT1?a73vLwxzjk4*ep9whNZ33Pdc=n+Emdo&7h;pQ3(4%AMs~{J3_?6~P z^o<`ukWBc-dK1p8%+wyZ5~ct*@Er%eJxCYrk)%YV;Ye9XlaOX2l_M=iT8Xq4X(Q6} zNV|~UMfwL)zrB)l8PYJMRHW%hHArrx%}863UPn5PbPlP1n7$gnGuV*Dlmr6sV%cMkU zsC2n>g_I;+Dg8jYN*X3zji2keRx(M~N!Lq1l#-?4(hcy7M@S>3o3v%j%)4>2lI5hQHS$xCpni915f)!CJp+b9jZoU;YkT~(8{Au!n9K04ZYcgoKO~V zTE_rXD3%xPEGt;b0Z);W9iez%__-$6%5^UIci3Cel5N)q<-F2x5xNkq5F;59G2`m1 zLT^aZ^Z)VB)14s(w;qPQJSa(RVP*SKW<^) zBqKE*bQq`1FIQWDY#qynTFNHs_@lKy!p?ENvkKZ~>#sTFBI(jlZ1 zNZm-Mk)$_qw+<;0$%Hfl$%>SVRD?7GX&zD~Qa#cNq%}zEkv1VckK{*cL+V62ilic) zMhbrZ2K-27q!~zykQ$JlM%s^b3`xQ`CL`q{%|Kd&q<>c6{h_e@_wxQfC-3`XX4)5W z{QFk>atw$<`63RM&Y}IrIFzlUGFz={F+gm~#!0`T{B)RYE&mMVISS5A2t?XKWwY#Z zs6>LtP&l;|j(cg5eaSS$mP%)dXnBk@uCkK6d9=Gh1mm?RJm!HGiMP?^8q^nQc|=>7 zHm7z-GPzFM2!h@}ND~mE76>~foV;K^K2;n+6Fbshr3p9*pHf}!D02|cM4^JDP>OC#upQ%>6D*ZSLv#;3tEBsPAZ#@WxS>g0inv7cBiXG z2L7K=`3y&01=z&)*GV+|p31cFE#?0ZmL~xYjGcm00*yxCE{L7(lIvY^5go$KVt0ah zxi=Qw*ku+E;n^Asq1$TlPoC7(E~e;wnWLI^u>{;5JFCWymGOptbIYn_$YmCsk{bK; z@}J;hBI;*L2%R`;mOAjBES1s`MIEj!!V`fXDdGH$cBy!OOe)3VSX+lzDIk?r*Og1s zgE6Jf+Io07a+UN-OzDzf1~5Zo`Cw4GCKmg&YTWUPt*W3C7iw>gt*WYVITz7;T5Q!q zyX=(G`MH$klo?ya4nkIJm4;oCvhnVcE2JELI;A{*3iz?Hh0*UuWVx2)6eh~{%RV=P2 zm|yX`z_XFwh3g>wn%;3MlVE;B@A#kIUyof{;ndy>C5#tN{YV}-^CPvE?hs`~)rIJp z!xfW-?_hUGOY}O#6mi6)og|`V-4w(S!G~T?^A+<9hh9`EJ)oCE?HDEMaQ-Mg5>~E* zv!619qGSXiNxwV~26LMumQZRAR*sXJbr`Y>Km-UjDEstsuo=#Zj{eoKdeQ&+xDN>! zn$#1jA;c-wwXDx?hRUbm9wrq_{}g55au!dL3Dx$RN^mhGhUHAuX<{BHy}@=u9A^=u zugA=&bB0?A@;UlQq(`3a6zKwEQ~>Q!jKV4p}Y(9!kYHqYQCQlK=km|AGV-Yw;h7 zMI?ZsB)E^nS9p00^5#Cu2N)1nLEXG#l9bsGFWM)wpA~O&q*+oa{@SFOc$+Lum!=^< z8Gk3>oj$J^K0QbM68;!OJ@n^TuEjn9|HW$W`r}b9n1xe52TuHIaRxX6PdXQzj9eAg zN?KSg>_FJ()&;J@&b$rNcR z_m+mx*JzwI*6|r*1=>-M4p3o7c`g3Z!Zi&so0uS7MJRPj6-;kE>Z{R$mnCTm-pi$8 zNN2p1BFzoMYzQljTV=kr|#&Mr*>j z4d;&9SE3fzX0XPML|;?TW+AsAY1KncB<+PPA@U1NpvjE?QbDPBOGnu(;4w*4(RMla zISRR4P)Zb(vXn)60i$3pW|^WEl$%ukyCY(8o}X};7l%2IBru{>;f9RI#uz|t?(p87@V#I(k=>oZd_ z^D`%8&di*fxgyh-`E=%gX13c zmzMwA{1@}peCycT$5xMZ(Bw8@kA=q+^F8LR=8w$%Eki6ru<*!KbikR{*L_4{CD%mjD2J*CW>?j{l0*4DNLP{+L`)k>fkg- z`cKoJOW&Jr9W!T4^_Yjo{Ao;C#>$M%87DF(Wd1mFapr@WZJBXd6SMBjx;yKqSsSzd zkhM4KaMsA|wCoAlv$Jo{wr4xCmu9=Oo3bCv-kkmW>}}b*vJYe*%6=#NW60vG?6{l+ zNaKc_(K#78ML9ppnVVCVb61Wl=e`_o&LcT5kZes2Dh{JX%<@%)&v*Nh!GcHG!0qz^L?o55qCxdM8) z&io5=v-zLqL`$+|Ds-aGveELY-Z6n2*Pt8uRs-i!ugh{2(JG<98W>414B*%-+nztVtO8`?J<%jmw^% zy*hh+_O!9}V?AR}6AcRxSHa_Y^BmCd1jh8B`JDN3i^X!Mr4}=x#d657HDi3Qv8G#X);jC2tS!*7_tU42`Q4az#so5MhRj!FuFhPa`RmMcnIp1_Felb! z9nGrEemJ`;`gX`cI*pdo5vm)`^MNW z$HK5no51r$<^=Oq<{QiwbFR6_JPj8{?l*5RZ!|vx861Z_h{gQ8-jZq=Zh-CqspC^;rk1BVQtwZFIQ7ZY7gP779!x!+dNMUOZAjYn zX{l-B(`KfXr#aH@PkT7+$+Q>K_M{!eIG#+4wGOdfZ%wt1x6ZVdTOHQ>tq)tDw6!Hby zXK%`WI{VpdViMC;%FQUqD9V_WF(qS0#_WuF8S^t1WK?D>%Babx&yX{gWvs|($Y{&} J;QvoP{{uEZBLe^c literal 0 HcmV?d00001 diff --git a/utils/jz4740_usbtool/windows_driver/libusb0.sys b/utils/jz4740_usbtool/windows_driver/libusb0.sys new file mode 100755 index 0000000000000000000000000000000000000000..0a02d3ee3319b77949c890c206b02c824007bb49 GIT binary patch literal 28672 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 literal 0 HcmV?d00001 diff --git a/utils/jz4740_usbtool/windows_driver/libusb0_x64.dll b/utils/jz4740_usbtool/windows_driver/libusb0_x64.dll new file mode 100755 index 0000000000000000000000000000000000000000..c89a59fe38b5cd1a9470b75deccb26b552ac1c7e GIT binary patch literal 43008 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 L7W$K?KkfNXdJ6SB literal 0 HcmV?d00001