static void configure_vop(void)
{
write32(&rk3288_grf->iomux_lcdc, IOMUX_LCDC);
/* lcdc(vop) iodomain select 1.8V */
write32(&rk3288_grf->io_vsel, RK_SETBITS(1 << 0));
switch (board_id()) {
case 0:
rk808_configure_switch(2, 1); /* VCC18_LCD */
rk808_configure_ldo(7, 2500); /* VCC10_LCD_PWREN_H */
rk808_configure_switch(1, 1); /* VCC33_LCD */
break;
default:
gpio_output(GPIO(2, B, 5), 1); /* AVDD_1V8_DISP_EN */
rk808_configure_ldo(7, 2500); /* VCC10_LCD_PWREN_H */
gpio_output(GPIO(7, B, 6), 1); /* LCD_EN */
rk808_configure_switch(1, 1); /* VCC33_LCD */
/* enable edp HPD */
gpio_input_pulldown(GPIO(7, B, 3));
write32(&rk3288_grf->iomux_edp_hotplug, IOMUX_EDP_HOTPLUG);
break;
}
}
void w25q80bv_target_init(w25q80bv_driver_t* const drv) {
(void)drv;
/* Init SPIFI GPIO to Normal GPIO */
scu_pinmux(P3_3, (SCU_SSP_IO | SCU_CONF_FUNCTION2)); // P3_3 SPIFI_SCK => SSP0_SCK
scu_pinmux(P3_4, (SCU_GPIO_FAST | SCU_CONF_FUNCTION0)); // P3_4 SPIFI SPIFI_SIO3 IO3 => GPIO1[14]
scu_pinmux(P3_5, (SCU_GPIO_FAST | SCU_CONF_FUNCTION0)); // P3_5 SPIFI SPIFI_SIO2 IO2 => GPIO1[15]
scu_pinmux(P3_6, (SCU_GPIO_FAST | SCU_CONF_FUNCTION0)); // P3_6 SPIFI SPIFI_MISO IO1 => GPIO0[6]
scu_pinmux(P3_7, (SCU_GPIO_FAST | SCU_CONF_FUNCTION4)); // P3_7 SPIFI SPIFI_MOSI IO0 => GPIO5[10]
scu_pinmux(P3_8, (SCU_GPIO_FAST | SCU_CONF_FUNCTION4)); // P3_8 SPIFI SPIFI_CS => GPIO5[11]
/* configure SSP pins */
scu_pinmux(SCU_SSP0_MISO, (SCU_SSP_IO | SCU_CONF_FUNCTION5));
scu_pinmux(SCU_SSP0_MOSI, (SCU_SSP_IO | SCU_CONF_FUNCTION5));
scu_pinmux(SCU_SSP0_SCK, (SCU_SSP_IO | SCU_CONF_FUNCTION2));
/* configure GPIO pins */
scu_pinmux(SCU_FLASH_HOLD, SCU_GPIO_FAST);
scu_pinmux(SCU_FLASH_WP, SCU_GPIO_FAST);
scu_pinmux(SCU_SSP0_SSEL, (SCU_GPIO_FAST | SCU_CONF_FUNCTION4));
/* drive SSEL, HOLD, and WP pins high */
gpio_set(drv->gpio_hold);
gpio_set(drv->gpio_wp);
/* Set GPIO pins as outputs. */
gpio_output(drv->gpio_hold);
gpio_output(drv->gpio_wp);
}
void bootblock_mainboard_early_init(void)
{
/* Let gpio2ab io domains works at 1.8V.
*
* If io_vsel[0] == 0(default value), gpio2ab io domains is 3.0V
* powerd by APIO2_VDD, otherwise, 1.8V supplied by APIO2_VDDPST.
* But from the schematic of kevin rev0, the APIO2_VDD and
* APIO2_VDDPST both are 1.8V(intentionally?).
*
* So, by default, CPU1_SDIO_PWREN(GPIO2_A2) can't output 3.0V
* because the supply is 1.8V.
* Let ask GPIO2_A2 output 1.8V to make GPIO interal logic happy.
*/
write32(&rk3399_grf->io_vsel, RK_SETBITS(1 << 0));
/*
* Let's enable these power rails here, we are already running the SPI
* Flash based code.
*/
gpio_output(GPIO(0, B, 2), 1); /* PP1500_EN */
gpio_output(GPIO(0, B, 4), 1); /* PP3000_EN */
if (IS_ENABLED(CONFIG_DRIVERS_UART)) {
_Static_assert(CONFIG_CONSOLE_SERIAL_UART_ADDRESS == UART2_BASE,
"CONSOLE_SERIAL_UART should be UART2");
/* iomux: select gpio4c[4:3] as uart2 dbg port */
write32(&rk3399_grf->iomux_uart2c, IOMUX_UART2C);
/* grf soc_con7[11:10] use for uart2 select */
write32(&rk3399_grf->soc_con7, UART2C_SEL);
}
}
/*******************
initialiseren van de constanten uit lader.h
*******************/
void init(){
gpio_map();
printf("We zijn in de lader.c\n");
gpio_output(DISCHARGE_BANK, DISCHARGE_PIN);
printf("lader1\n");
gpio_output(ON_OFF_BANK, ON_OFF_PIN);
printf("lader2\n");
turnOff();
printf("lader3\n");
charge();
printf("lader4\n");
currentCharger=0; //uitgedrukt in mA
printf("lader5\n");
//On: 1, off: 0
on=0;
//Charging: 1, discharging: 0
charging=1;
// Variabelen voor State of Charge
integratedCurrent=0; // Accumulatie van vorige stromen
printf("lader6\n");
timeOfMeasurement=0;
//Lipo: 0, NiMH: 1
batterij_type = LiPo;
// Toestanden voor relay-standen
status = USE;
printf("lader7\n");
}
int init(){
gpio_map();
gpio_output(DISCHARGE_BANK, DISCHARGE_PIN);
gpio_output(ON_OFF_BANK, ON_OFF_PIN);
turnOff();
charge();
return 0;
}
void cpld_jtag_setup(jtag_t* const jtag) {
scu_pinmux(SCU_PINMUX_CPLD_TDO, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION4);
scu_pinmux(SCU_PINMUX_CPLD_TCK, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION0);
scu_pinmux(SCU_PINMUX_CPLD_TMS, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION0);
scu_pinmux(SCU_PINMUX_CPLD_TDI, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION0);
gpio_input(jtag->gpio->gpio_tdo);
gpio_output(jtag->gpio->gpio_tck);
gpio_output(jtag->gpio->gpio_tms);
gpio_output(jtag->gpio->gpio_tdi);
}
static void configure_hdmi(void)
{
rk808_configure_switch(2, 1); /* VCC18_LCD (HDMI_AVDD_1V8) */
rk808_configure_ldo(7, 1000); /* VDD10_LCD (HDMI_AVDD_1V0) */
/* set POWER_HDMI_EN */
switch (board_id()) {
case 0:
gpio_output(GPIO(7, A, 2), 1);
break;
default:
gpio_output(GPIO(5, C, 3), 1);
break;
}
}
void ate_version_set(void)
{
unsigned i = 0;
unsigned ate_vector_temp = 0;
unsigned ate_ver_bit[8];
if(ate_vector_version > 255){
return ;
}
ate_vector_temp = ate_vector_version;
for(i = 0; i < 8; i++){
ate_ver_bit[i] = 0;
}
for(i = 0; ate_vector_temp != 0; i++)
{
ate_ver_bit[i] = ate_vector_temp % 2;
ate_vector_temp = ate_vector_temp / 2;
}
for(i = 0; i < 8; i++){
gpio_output(ATE_GPIO_VECTOR_GRP, i, ate_ver_bit[i]);
}
return;
}
static void configure_usb(void)
{
gpio_output(GPIO(0, B, 3), 1); /* HOST1_PWR_EN */
gpio_output(GPIO(0, B, 4), 1); /* USBOTG_PWREN_H */
switch (board_id()) {
case 0:
gpio_output(GPIO(7, B, 3), 1); /* 5V_DRV */
break;
case 1:
break; /* 5V_DRV moved to EC in rev2 */
default:
gpio_output(GPIO(7, C, 5), 1); /* 5V_DRV, again */
break;
}
}
void bootblock_mainboard_init(void)
{
if (rkclk_was_watchdog_reset())
reboot_from_watchdog();
gpio_output(GPIO(0, B, 3), 1); /* Power LED */
/* Up VDD_CPU (BUCK1) to 1.4V to support max CPU frequency (1.8GHz). */
setbits_le32(&rk3288_pmu->iomux_i2c0scl, IOMUX_I2C0SCL);
setbits_le32(&rk3288_pmu->iomux_i2c0sda, IOMUX_I2C0SDA);
assert(CONFIG_PMIC_BUS == 0); /* must correspond with IOMUX */
i2c_init(CONFIG_PMIC_BUS, 400*KHz);
/* Slowly raise to max CPU voltage to prevent overshoot */
rk808_configure_buck(1, 1200);
udelay(175);/* Must wait for voltage to stabilize,2mV/us */
rk808_configure_buck(1, 1400);
udelay(100);/* Must wait for voltage to stabilize,2mV/us */
rkclk_configure_cpu(APLL_1800_MHZ);
/* i2c1 for tpm */
write32(&rk3288_grf->iomux_i2c1, IOMUX_I2C1);
i2c_init(1, 400*KHz);
/* spi2 for firmware ROM */
write32(&rk3288_grf->iomux_spi2csclk, IOMUX_SPI2_CSCLK);
write32(&rk3288_grf->iomux_spi2txrx, IOMUX_SPI2_TXRX);
rockchip_spi_init(CONFIG_BOOT_MEDIA_SPI_BUS, 24750*KHz);
setup_chromeos_gpios();
}
static void configure_emmc(void)
{
write32(&rk3288_grf->iomux_emmcdata, IOMUX_EMMCDATA);
write32(&rk3288_grf->iomux_emmcpwren, IOMUX_EMMCPWREN);
write32(&rk3288_grf->iomux_emmccmd, IOMUX_EMMCCMD);
gpio_output(GPIO(2, B, 1), 1); /* EMMC_RST_L */
}
void gpio_unexport(int gpioNr) {
const char *filename = "/sys/class/gpio/unexport";
char buf[BUF_LEN];
sprintf(buf, "%d", gpioNr);
gpio_output(filename, buf);
}
static void configure_emmc(void)
{
writel(IOMUX_EMMCDATA, &rk3288_grf->iomux_emmcdata);
writel(IOMUX_EMMCPWREN, &rk3288_grf->iomux_emmcpwren);
writel(IOMUX_EMMCCMD, &rk3288_grf->iomux_emmccmd);
gpio_output(GPIO(2, B, 1), 1); /* EMMC_RST_L */
}
void setup_chromeos_gpios(void)
{
gpio_input(GPIO_WP);
gpio_input_pullup(EC_IN_RW);
gpio_input_pullup(EC_IRQ);
gpio_input_pullup(CR50_IRQ);
gpio_output(GPIO_RESET, 0);
}
static void mainboard_init(device_t dev)
{
gpio_output(GPIO_RESET, 0);
configure_usb();
configure_emmc();
configure_codec();
configure_vop();
}
static void configure_hdmi(void)
{
rk808_configure_switch(2, 1); /* VCC18_LCD (HDMI_AVDD_1V8) */
rk808_configure_ldo(7, 1000); /* VDD10_LCD (HDMI_AVDD_1V0) */
rk808_configure_switch(1, 1); /* VCC33_LCD */
/* set POWER_HDMI_ON */
gpio_output(GPIO(7, A, 2), 1);
}
void gpio_set(int gpioNr, int val) {
char filename[BUF_LEN];
sprintf(filename, "/sys/class/gpio/gpio%d/value", gpioNr);
char buf[BUF_LEN];
sprintf(buf, "%d", val);
gpio_output(filename, buf);
}
void setup_chromeos_gpios(void)
{
gpio_input(WRITE_PROTECT);
gpio_input_pullup(EC_IN_RW);
gpio_input_pullup(EC_IRQ);
gpio_input_pullup(LID);
gpio_input_pullup(POWER_BUTTON);
gpio_output(EC_SUSPEND_L, 1);
}
static void setup_pinmux(void)
{
/* Write protect. */
gpio_input_pullup(GPIO(R1));
/* Recovery mode. */
gpio_input_pullup(GPIO(Q7));
/* Lid switch. */
gpio_input_pullup(GPIO(R4));
/* Power switch. */
gpio_input_pullup(GPIO(Q0));
/* Developer mode. */
gpio_input_pullup(GPIO(Q6));
/* EC in RW. */
gpio_input_pullup(GPIO(U4));
/* route PU4/5 to GMI to remove conflict w/PWM1/2. */
pinmux_set_config(PINMUX_GPIO_PU4_INDEX,
PINMUX_GPIO_PU4_FUNC_NOR); /* s/b GMI */
pinmux_set_config(PINMUX_GPIO_PU5_INDEX,
PINMUX_GPIO_PU5_FUNC_NOR); /* s/b GMI */
/* SOC and TPM reset GPIO, active low. */
gpio_output(GPIO(I5), 1);
/* SPI1 MOSI */
pinmux_set_config(PINMUX_ULPI_CLK_INDEX, PINMUX_ULPI_CLK_FUNC_SPI1 |
PINMUX_PULL_NONE |
PINMUX_INPUT_ENABLE);
/* SPI1 MISO */
pinmux_set_config(PINMUX_ULPI_DIR_INDEX, PINMUX_ULPI_DIR_FUNC_SPI1 |
PINMUX_PULL_NONE |
PINMUX_INPUT_ENABLE);
/* SPI1 SCLK */
pinmux_set_config(PINMUX_ULPI_NXT_INDEX, PINMUX_ULPI_NXT_FUNC_SPI1 |
PINMUX_PULL_NONE |
PINMUX_INPUT_ENABLE);
/* SPI1 CS0 */
pinmux_set_config(PINMUX_ULPI_STP_INDEX, PINMUX_ULPI_STP_FUNC_SPI1 |
PINMUX_PULL_NONE |
PINMUX_INPUT_ENABLE);
/* I2C3 (cam) clock. */
pinmux_set_config(PINMUX_CAM_I2C_SCL_INDEX,
PINMUX_CAM_I2C_SCL_FUNC_I2C3 | PINMUX_INPUT_ENABLE);
/* I2C3 (cam) data. */
pinmux_set_config(PINMUX_CAM_I2C_SDA_INDEX,
PINMUX_CAM_I2C_SDA_FUNC_I2C3 | PINMUX_INPUT_ENABLE);
/* switch unused pin to GPIO */
gpio_set_mode(GPIO(X3), GPIO_MODE_GPIO);
gpio_set_mode(GPIO(X4), GPIO_MODE_GPIO);
gpio_set_mode(GPIO(X5), GPIO_MODE_GPIO);
gpio_set_mode(GPIO(X6), GPIO_MODE_GPIO);
gpio_set_mode(GPIO(X7), GPIO_MODE_GPIO);
gpio_set_mode(GPIO(W3), GPIO_MODE_GPIO);
}
void initialise_io() {
gpio_map();
gpio_output(BBGPIO_01);
gpio_output(BBGPIO_02);
gpio_output(BBGPIO_04);
gpio_output(BBGPIO_05);
gpio_output(BBGPIO_06);
gpio_output(BBGPIO_07);
gpio_output(BBGPIO_16);
gpio_output(BBGPIO_51);
}
void setup_chromeos_gpios(void)
{
gpio_input(WRITE_PROTECT);
gpio_input_pullup(EC_IN_RW);
gpio_input_pullup(EC_IRQ);
gpio_input_pullup(LID);
gpio_input_pullup(POWER_BUTTON);
if (board_id() + CONFIG_BOARD_ID_ADJUSTMENT < 5)
gpio_output(EC_SUSPEND_L, 1);
}
static void configure_vop(void)
{
write32(&rk3288_grf->iomux_lcdc, IOMUX_LCDC);
/* lcdc(vop) iodomain select 1.8V */
write32(&rk3288_grf->io_vsel, RK_SETBITS(1 << 0));
/*
* BL_EN gates VCC_LCD. This might be changed in future revisions
* of the board so that the display can be stablized before we
* turn on the backlight.
*
* To minimize display corruption, turn off LCDC_BL before
* powering on the backlight.
*/
switch (board_id()) {
case 0:
gpio_output(GPIO(7, A, 3), 1);
break;
default:
gpio_output(GPIO(7, A, 2), 1);
break;
}
gpio_output(GPIO_LCDC_BL, 0);
rk808_configure_switch(1, 1); /* VCC33_LCD */
/* EDP_HPD setup */
switch (board_id()) {
case 0:
/* not present */
break;
default:
/* Unlike other Veyrons, Danger has external pull resistors on
* EDP_HPD. Default for GPIO(7, B, 3) is pull-down, set to
* float.
*/
gpio_input(GPIO(7, B, 3));
write32(&rk3288_grf->iomux_edp_hotplug, IOMUX_EDP_HOTPLUG);
break;
}
}
static void configure_hdmi(void)
{
rk808_configure_switch(2, 1); /* VCC18_LCD (HDMI_AVDD_1V8) */
rk808_configure_ldo(7, 1000); /* VDD10_LCD (HDMI_AVDD_1V0) */
rk808_configure_switch(1, 1); /* VCC33_LCD */
/* set POWER_HDMI_ON */
gpio_output(GPIO(7, A, 2), 1);
/* HDMI I2C */
write32(&rk3288_grf->iomux_i2c5sda, IOMUX_HDMI_EDP_I2C_SDA);
write32(&rk3288_grf->iomux_i2c5scl, IOMUX_HDMI_EDP_I2C_SCL);
}
static void mainboard_init(device_t dev)
{
gpio_output(GPIO_RESET, 0);
configure_usb();
configure_emmc();
configure_codec();
/* No video. */
elog_init();
elog_add_watchdog_reset();
elog_add_boot_reason();
}
void pin_setup(void) {
/* Release CPLD JTAG pins */
scu_pinmux(SCU_PINMUX_TDO, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION4);
scu_pinmux(SCU_PINMUX_TCK, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION0);
scu_pinmux(SCU_PINMUX_TMS, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION0);
scu_pinmux(SCU_PINMUX_TDI, SCU_GPIO_NOPULL | SCU_CONF_FUNCTION0);
gpio_input(&gpio_tdo);
gpio_input(&gpio_tck);
gpio_input(&gpio_tms);
gpio_input(&gpio_tdi);
/* Configure SCU Pin Mux as GPIO */
scu_pinmux(SCU_PINMUX_LED1, SCU_GPIO_NOPULL);
scu_pinmux(SCU_PINMUX_LED2, SCU_GPIO_NOPULL);
scu_pinmux(SCU_PINMUX_LED3, SCU_GPIO_NOPULL);
scu_pinmux(SCU_PINMUX_LED4, SCU_GPIO_NOPULL);
/* Configure all GPIO as Input (safe state) */
gpio_init();
gpio_output(&gpio_led[0]);
gpio_output(&gpio_led[1]);
gpio_output(&gpio_led[2]);
gpio_output(&gpio_led[3]);
/* enable input on SCL and SDA pins */
SCU_SFSI2C0 = SCU_I2C0_NOMINAL;
/* Configure external clock in */
scu_pinmux(CLK0, SCU_CONF_FUNCTION1 | SCU_CLK_OUT);
/* Enable USB1 controller */
SCU_SFSUSB = 0x2;
scu_pinmux(SCU_PINMUX_USB1_EN, SCU_CONF_FUNCTION0);
gpio_output(&gpio_usb1_en);
gpio_set(&gpio_usb1_en);
}
static void mainboard_init(device_t dev)
{
setbits_le32(&rk3288_pmu->iomux_i2c0scl, IOMUX_I2C0SCL); /* PMIC I2C */
setbits_le32(&rk3288_pmu->iomux_i2c0sda, IOMUX_I2C0SDA); /* PMIC I2C */
i2c_init(0, 400000); /* PMIC I2C */
gpio_output(GPIO_RESET, 0);
configure_usb();
configure_sdmmc();
configure_emmc();
configure_codec();
configure_vop();
}
FUN_ATTRIBUTE
void product_power_control(uint8 power)
{
gpio_output(PLUG_POWR_PIN, power);
char *msg = get_plug_state();
if (msg == NULL)
{
os_printf("get_product_state error");
return;
}
send_data_to_cloud(msg, strlen(msg));
free(msg);
return;
}
void sgpio_configure_pin_functions(sgpio_config_t* const config) {
scu_pinmux(SCU_PINMUX_SGPIO0, SCU_GPIO_FAST | SCU_CONF_FUNCTION3);
scu_pinmux(SCU_PINMUX_SGPIO1, SCU_GPIO_FAST | SCU_CONF_FUNCTION3);
scu_pinmux(SCU_PINMUX_SGPIO2, SCU_GPIO_FAST | SCU_CONF_FUNCTION2);
scu_pinmux(SCU_PINMUX_SGPIO3, SCU_GPIO_FAST | SCU_CONF_FUNCTION2);
scu_pinmux(SCU_PINMUX_SGPIO4, SCU_GPIO_FAST | SCU_CONF_FUNCTION2);
scu_pinmux(SCU_PINMUX_SGPIO5, SCU_GPIO_FAST | SCU_CONF_FUNCTION2);
scu_pinmux(SCU_PINMUX_SGPIO6, SCU_GPIO_FAST | SCU_CONF_FUNCTION0);
scu_pinmux(SCU_PINMUX_SGPIO7, SCU_GPIO_FAST | SCU_CONF_FUNCTION6);
scu_pinmux(SCU_PINMUX_SGPIO8, SCU_GPIO_FAST | SCU_CONF_FUNCTION6);
scu_pinmux(SCU_PINMUX_SGPIO9, SCU_GPIO_FAST | SCU_CONF_FUNCTION7);
scu_pinmux(SCU_PINMUX_SGPIO10, SCU_GPIO_FAST | SCU_CONF_FUNCTION6);
scu_pinmux(SCU_PINMUX_SGPIO11, SCU_GPIO_FAST | SCU_CONF_FUNCTION6);
scu_pinmux(SCU_PINMUX_SGPIO12, SCU_GPIO_FAST | SCU_CONF_FUNCTION0); /* GPIO0[13] */
scu_pinmux(SCU_PINMUX_SGPIO13, SCU_GPIO_FAST | SCU_CONF_FUNCTION4); /* GPIO5[12] */
scu_pinmux(SCU_PINMUX_SGPIO14, SCU_GPIO_FAST | SCU_CONF_FUNCTION4); /* GPIO5[13] */
scu_pinmux(SCU_PINMUX_SGPIO15, SCU_GPIO_FAST | SCU_CONF_FUNCTION4); /* GPIO5[14] */
sgpio_cpld_stream_rx_set_q_invert(config, 0);
hw_sync_enable(0);
gpio_output(config->gpio_rx_q_invert);
gpio_output(config->gpio_hw_sync_enable);
}
void blink(const ff_gpio *gpio)
{
int i;
printf("blink\n");
gpio_input(gpio);
gpio_output(gpio);
printf("Start loop\n");
for (i = 0; i < 10; ++i)
{
gpio_high(gpio);
sleep(1);
gpio_low(gpio);
sleep(1);
}
}
static void configure_3g(void)
{
/* Force 3G modem off to avoid confusing the EHCI host and
* causing problems during enumeration/init */
gpio_output(GPIO(5, C, 1), 1); /* 3G_SHUTDOWN */
gpio_output(GPIO(4, D, 2), 0); /* 3G_ON_OFF */
}
