int main(int argc, char *argv[]) { int counter = 250; srand(time(NULL)); gpio_open(15); gpio_open(16); gpio_open(17); gpio_set_direction(15, "out"); gpio_set_direction(16, "out"); gpio_set_direction(17, "out"); /* blink leds randomly with random delay */ while (counter > 0) { gpio_set(random(15, 17), random(0, 1)); delay(random(0, random(MIN_DELAY_VALUE, MAX_DELAY_VALUE))); counter--; } /* Turn off all leds */ gpio_set(17, 1); gpio_set(16, 1); gpio_set(15, 1); gpio_close_all(); return 0; }
static int jtag_open(struct jtag_state *state) { gpio_export(TDI_GPIO); gpio_export(TMS_GPIO); gpio_export(TCK_GPIO); gpio_export(TDO_GPIO); gpio_set_direction(TDI_GPIO, 0); gpio_set_direction(TMS_GPIO, 1); gpio_set_direction(TCK_GPIO, 1); gpio_set_direction(TDO_GPIO, 1); gpio_set_value(TDO_GPIO, 0); gpio_set_value(TMS_GPIO, 0); gpio_set_value(TCK_GPIO, 0); state->tdi = TDI_GPIO; state->tms = TMS_GPIO; state->tck = TCK_GPIO; state->tdo = TDO_GPIO; jtag_reset(state); return 0; }
/*! * Provide the mipi camera power and reset */ void mipi_cam_power_on(void) { #if defined(BOARD_EVB) board_ioexpander_iomux_config(); /*reset of camera sensor, pin 27 */ max7310_set_gpio_output(0, 2, GPIO_LOW_LEVEL); hal_delay_us(1000); max7310_set_gpio_output(0, 2, GPIO_HIGH_LEVEL); /*power supply through pin25 of connector, for cam_pdown, power down and then up */ max7310_set_gpio_output(0, 0, GPIO_LOW_LEVEL); hal_delay_us(1000); max7310_set_gpio_output(0, 0, GPIO_HIGH_LEVEL); // max7310_set_gpio_output(1, 1, GPIO_HIGH_LEVEL); #endif #if defined(BOARD_SABRE_AI) board_ioexpander_iomux_config(); /*power supply through pin25 of connector, direct connected to P3V3_DELAY, controlled by CPU_PER_RST_B */ /*reset of camera sensor, together with the reset button */ max7310_set_gpio_output(0, 2, GPIO_LOW_LEVEL); hal_delay_us(1000); max7310_set_gpio_output(0, 2, GPIO_HIGH_LEVEL); max7310_set_gpio_output(0, 0, GPIO_HIGH_LEVEL); #endif #if defined(BOARD_SMART_DEVICE) /*power supply through pin25 of connector, for cam_pdown */ gpio_set_gpio(GPIO_PORT6, 9); HW_IOMUXC_SW_PAD_CTL_PAD_NAND_WP_B_WR( BF_IOMUXC_SW_PAD_CTL_PAD_NAND_WP_B_HYS_V(ENABLED) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_WP_B_PUS_V(100K_OHM_PU) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_WP_B_PUE_V(PULL) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_WP_B_PKE_V(ENABLED) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_WP_B_ODE_V(DISABLED) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_WP_B_SPEED_V(100MHZ) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_WP_B_DSE_V(40_OHM) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_WP_B_SRE_V(SLOW)); gpio_set_direction(GPIO_PORT6, 9, GPIO_GDIR_OUTPUT); gpio_set_level(GPIO_PORT6, 9, GPIO_HIGH_LEVEL); /*reset of camera sensor, pin 27 */ gpio_set_gpio(GPIO_PORT6, 10); HW_IOMUXC_SW_PAD_CTL_PAD_NAND_READY_WR( BF_IOMUXC_SW_PAD_CTL_PAD_NAND_READY_HYS_V(ENABLED) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_READY_PUS_V(100K_OHM_PU) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_READY_PUE_V(PULL) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_READY_PKE_V(ENABLED) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_READY_ODE_V(DISABLED) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_READY_SPEED_V(100MHZ) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_READY_DSE_V(40_OHM) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_READY_SRE_V(SLOW)); gpio_set_direction(GPIO_PORT6, 10, GPIO_GDIR_OUTPUT); gpio_set_level(GPIO_PORT6, 10, GPIO_LOW_LEVEL); hal_delay_us(1000); gpio_set_level(GPIO_PORT6, 10, GPIO_HIGH_LEVEL); #endif }
/*! * enable mipi backlight */ void mipi_backlight_en(void) { //configure pin19 of the mipi dsi/csi connector #ifdef BOARD_EVB //set GPIO1_9 to 0 so clear vbus on board gpio_set_direction(GPIO_PORT1, 9, GPIO_GDIR_OUTPUT); gpio_set_level(GPIO_PORT1, 9, GPIO_HIGH_LEVEL); #endif #ifdef BOARD_SABRE_AI //default be populated by P3V3_DELAYED #endif #ifdef BOARD_SMART_DEVICE gpio_set_gpio(GPIO_PORT2, 0); HW_IOMUXC_SW_PAD_CTL_PAD_NAND_DATA00_WR( BF_IOMUXC_SW_PAD_CTL_PAD_NAND_DATA00_HYS_V(ENABLED) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_DATA00_PUS_V(100K_OHM_PU) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_DATA00_PUE_V(PULL) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_DATA00_PKE_V(ENABLED) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_DATA00_ODE_V(DISABLED) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_DATA00_SPEED_V(100MHZ) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_DATA00_DSE_V(40_OHM) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_DATA00_SRE_V(SLOW)); gpio_set_direction(GPIO_PORT2, 0, GPIO_GDIR_OUTPUT); gpio_set_level(GPIO_PORT2, 0, GPIO_HIGH_LEVEL); #endif }
//Even though it's annoying to be locked into these 4 gpio pins, the fact //that they'll always work without physical adjustment is a nice feature void initIO(){ //Mode0 names char gpio1[] = "gpmc_wait0"; char gpio2[] = "gpmc_wpn"; char gpio3[] = "gpmc_a0"; char gpio4[] = "spi0_cs0"; int i; //Set pin mux in gpio output mode for controlGPIOss #ifdef SET_PIN_MUX mode_gpio_out(gpio1); mode_gpio_out(gpio2); mode_gpio_out(gpio3); mode_gpio_out(gpio4); #endif //Export gpios and set up output direction for controlGPIOss for (i = 0; i < 5; i++){ gpio_export(controlGPIOs[i]); gpio_set_direction(controlGPIOs[i], 1); } //Toggle switch gpio printf("%d\n", controlGPIOs[4]); gpio_export(controlGPIOs[4]); gpio_set_direction(controlGPIOs[4], 0); }
void lcd_attach( device_t parent, device_t self, void *aux ) { struct imx51_ipuv3_softc *sc = device_private(self); struct axi_attach_args *axia = aux; bus_space_tag_t iot = axia->aa_iot; sc->dev = self; /* XXX move this to imx51_ipuv3.c */ { bus_space_handle_t mipi_ioh; uint32_t reg; if (bus_space_map(iot, 0x83fdc000, 0x1000, 0, &mipi_ioh)) aprint_error_dev(self, "can't map MIPI HSC"); else { bus_space_write_4(iot, mipi_ioh, 0x000, 0xf00); reg = bus_space_read_4(iot, mipi_ioh, 0x800); bus_space_write_4(iot, mipi_ioh, 0x800, reg | 0x0ff); reg = bus_space_read_4(iot, mipi_ioh, 0x800); bus_space_write_4(iot, mipi_ioh, 0x800, reg | 0x10000); } } /* LCD power on */ gpio_set_direction(GPIO_NO(4, 9), GPIO_DIR_OUT); gpio_set_direction(GPIO_NO(4, 10), GPIO_DIR_OUT); gpio_set_direction(GPIO_NO(3, 3), GPIO_DIR_OUT); gpio_data_write(GPIO_NO(3, 3), 1); gpio_data_write(GPIO_NO(4, 9), 1); delay(180 * 1000); gpio_data_write(GPIO_NO(4, 10), 1); gpio_set_direction(GPIO_NO(2, 13), GPIO_DIR_OUT); gpio_data_write(GPIO_NO(2, 13), 1); imx51_ipuv3_attach_sub(sc, aux, &sharp_panel); #if NWSDISPLAY == 0 struct imx51_ipuv3_screen *screen; int error; error = imx51_ipuv3_new_screen(sc, &screen); #ifdef LCD_DEBUG draw_test_pattern(sc, screen); #endif if (error == 0) { sc->active = screen; imx51_ipuv3_start_dma(sc, screen); } #endif }
void phy_rmii_smi_configure_pins(uint8_t mdc_gpio, uint8_t mdio_gpio) { // setup SMI MDC pin gpio_set_direction(mdc_gpio, GPIO_MODE_OUTPUT); gpio_matrix_out(mdc_gpio, EMAC_MDC_O_IDX, 0, 0); PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[mdc_gpio], PIN_FUNC_GPIO); // setup SMI MDIO pin gpio_set_direction(mdio_gpio, GPIO_MODE_INPUT_OUTPUT); gpio_matrix_out(mdio_gpio, EMAC_MDO_O_IDX, 0, 0); gpio_matrix_in(mdio_gpio, EMAC_MDI_I_IDX, 0); PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[mdio_gpio], PIN_FUNC_GPIO); }
void ws2812_init(int gpioNum) { SET_PERI_REG_MASK(DPORT_PERIP_CLK_EN_REG, DPORT_RMT_CLK_EN); CLEAR_PERI_REG_MASK(DPORT_PERIP_RST_EN_REG, DPORT_RMT_RST); PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[gpioNum], 2); gpio_matrix_out(gpioNum, RMT_SIG_OUT0_IDX + RMTCHANNEL, 0, 0); gpio_set_direction(gpioNum, GPIO_MODE_OUTPUT); ws2812_initRMTChannel(RMTCHANNEL); RMT.tx_lim_ch[RMTCHANNEL].limit = MAX_PULSES; RMT.int_ena.ch0_tx_thr_event = 1; RMT.int_ena.ch0_tx_end = 1; ws2812_bits[0].level0 = 1; ws2812_bits[0].level1 = 0; ws2812_bits[0].duration0 = PULSE_T0H; ws2812_bits[0].duration1 = PULSE_T0L; ws2812_bits[1].level0 = 1; ws2812_bits[1].level1 = 0; ws2812_bits[1].duration0 = PULSE_T1H; ws2812_bits[1].duration1 = PULSE_T1L; esp_intr_alloc(ETS_RMT_INTR_SOURCE, 0, ws2812_handleInterrupt, NULL, &rmt_intr_handle); return; }
int softpwm_start(const char *key, float duty, float freq, int polarity) { struct softpwm *new_pwm, *pwm; pthread_t new_thread; pthread_mutex_t *new_params_lock; int gpio; int ret; if (get_gpio_number(key, &gpio) < 0) return -1; if (gpio_export(gpio) < 0) return -1; if (gpio_set_direction(gpio, OUTPUT) < 0) return -1; // add to list new_pwm = malloc(sizeof(struct softpwm)); ASSRT(new_pwm != NULL); new_params_lock = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)); if (new_pwm == 0) { return -1; // out of memory } pthread_mutex_init(new_params_lock, NULL); pthread_mutex_lock(new_params_lock); strncpy(new_pwm->key, key, KEYLEN); /* can leave string unterminated */ new_pwm->key[KEYLEN] = '\0'; /* terminate string */ new_pwm->gpio = gpio; new_pwm->params.enabled = true; new_pwm->params.stop_flag = false; new_pwm->params_lock = new_params_lock; new_pwm->next = NULL; if (exported_pwms == NULL) { // create new list exported_pwms = new_pwm; } else { // add to end of existing list pwm = exported_pwms; while (pwm->next != NULL) pwm = pwm->next; pwm->next = new_pwm; } pthread_mutex_unlock(new_params_lock); ASSRT(softpwm_set_duty_cycle(new_pwm->key, duty) == 0); ASSRT(softpwm_set_frequency(new_pwm->key, freq) == 0); ASSRT(softpwm_set_polarity(new_pwm->key, polarity) == 0); pthread_mutex_lock(new_params_lock); // create thread for pwm ret = pthread_create(&new_thread, NULL, softpwm_thread_toggle, (void *)new_pwm); ASSRT(ret == 0); new_pwm->thread = new_thread; pthread_mutex_unlock(new_params_lock); return 1; }
/* This replaces the default PHY power on/off function with one that also uses a GPIO for power on/off. If this GPIO is not connected on your device (and PHY is always powered), you can use the default PHY-specific power on/off function rather than overriding with this one. */ static void phy_device_power_enable_via_gpio(bool enable) { assert(DEFAULT_ETHERNET_PHY_CONFIG.phy_power_enable); if (!enable) { /* Do the PHY-specific power_enable(false) function before powering down */ DEFAULT_ETHERNET_PHY_CONFIG.phy_power_enable(false); } gpio_pad_select_gpio(PIN_PHY_POWER); gpio_set_direction(PIN_PHY_POWER,GPIO_MODE_OUTPUT); if(enable == true) { gpio_set_level(PIN_PHY_POWER, 1); ESP_LOGD(TAG, "phy_device_power_enable(TRUE)"); } else { gpio_set_level(PIN_PHY_POWER, 0); ESP_LOGD(TAG, "power_enable(FALSE)"); } // Allow the power up/down to take effect, min 300us vTaskDelay(1); if (enable) { /* Run the PHY-specific power on operations now the PHY has power */ DEFAULT_ETHERNET_PHY_CONFIG.phy_power_enable(true); } }
int main(int argc,char **argv) { unsigned int ret; int i; GPIO_OPEN(); printf("\n%s entered\n",argv[0]); /* //gpio output test gpio_set_port_data(0x80); gpio_set_direction(0xff); gpio_set_int_mask(0xff); gpio_set_event_type(0xff); ret = gpio_get_int_status(); */ for(i=0;i<0xffff;i++); //gpio input test gpio_set_direction(0x0); gpio_set_int_mask(0x0); gpio_set_event_type(0xff); ret = gpio_get_port_data(); printf("get port data = 0x%x\n",ret); ret = gpio_get_int_status(); printf("gpio status = %x\n",ret); GPIO_CLOSE(); return 0; }
/* HAL functions */ int sj_gpio_set_mode(int pin, enum gpio_mode mode, enum gpio_pull_type pull) { if (mode == GPIO_MODE_INOUT) { fprintf(stderr, "Inout mode is not supported\n"); return -1; } if (pull != GPIO_PULL_FLOAT) { /* * Documented API for using internal pullup/pulldown * resistors requires kernel built with special flags * Basically, it works in Raspberian only * (and causes crash in another Linux) * Do not support internal pulling for now */ fprintf(stderr, "Pullup/pulldown aren't supported\n"); return -1; } if (gpio_export(pin) < 0) { return -1; } if (mode == GPIO_MODE_INT) { /* * GPIO should be in "IN" mode * for using /sys/edge */ mode = GPIO_MODE_INPUT; } return gpio_set_direction(pin, mode); }
static void phy_device_power_enable_via_gpio(bool enable) { assert(DEFAULT_ETHERNET_PHY_CONFIG.phy_power_enable); if (!enable) { DEFAULT_ETHERNET_PHY_CONFIG.phy_power_enable(false); } gpio_pad_select_gpio(PIN_PHY_POWER); gpio_set_direction(PIN_PHY_POWER, GPIO_MODE_OUTPUT); if (enable == true) { gpio_set_level(PIN_PHY_POWER, 1); ESP_LOGI(__func__, "Power On Ethernet PHY"); } else { gpio_set_level(PIN_PHY_POWER, 0); ESP_LOGI(__func__, "Power Off Ethernet PHY"); } vTaskDelay(1); // Allow the power up/down to take effect, min 300us if (enable) { /* call the default PHY-specific power on function */ DEFAULT_ETHERNET_PHY_CONFIG.phy_power_enable(true); } }
void gpio_init(int gpio_id, char* direction, char value) { gpio_export(gpio_id); gpio_set_direction(gpio_id, direction); if (!strcmp(direction, "out")) { gpio_set_value(gpio_id, value); } }
int setup_pins(int gpionum) { /* * Create the required GPIO pin and reserve it */ if (gpio_alloc(gpionum)) { fprintf(stderr, "Error allocating GPIO %d, errno = %d\n", gpionum, errno); return (1); } if (gpio_set_direction(gpionum, "out")) { fprintf(stderr, "Error setting GPIO %d direction, errno = %d\n", gpionum, errno); return (1); } if (gpio_write_pin(gpionum, "1")) { fprintf(stderr, "Error setting GPIO %d value, errno = %d\n", gpionum, errno); return (1); } return(0); }
/** * Initialize the device. * @param device - The device structure. * @param init_param - The structure that contains the device initial * parameters. * @return 0 in case of success, negative error code otherwise. */ int32_t adaq7980_setup(adaq7980_dev **device, adaq7980_init_param init_param) { adaq7980_dev *dev; int32_t ret = 0; dev = (adaq7980_dev *)malloc(sizeof(*dev)); if (!dev) { return -1; } dev->spi_dev.chip_select = init_param.spi_chip_select; dev->spi_dev.mode = init_param.spi_mode; dev->spi_dev.device_id = init_param.spi_device_id; dev->spi_dev.type = init_param.spi_type; dev->gpio_dev.device_id = init_param.gpio_device_id; dev->gpio_dev.type = init_param.gpio_type; ret |= gpio_init(&dev->gpio_dev); dev->gpio_pd_ldo = init_param.gpio_pd_ldo; ret |= gpio_set_direction(&dev->gpio_dev, dev->gpio_pd_ldo, GPIO_OUT); ret |= gpio_set_value(&dev->gpio_dev, dev->gpio_pd_ldo, GPIO_LOW); mdelay(10); ret |= gpio_set_value(&dev->gpio_dev, dev->gpio_pd_ldo, GPIO_HIGH); mdelay(10); *device = dev; if (!ret) printf("adaq7980 successfully initialized\n"); return ret; }
/* * Reserve a GPIO and set it as output. Than set the state * and release the port. * @gpio the GPIO pin to set the state for. * @state 1 or 0 * @return true if the state change was successful. */ bool gpio_write_and_close(int gpio, int state) { return gpio_reserve(gpio) && gpio_set_direction(gpio, GPIO_OUT) && gpio_set_state(gpio, state) && gpio_release(gpio); }
void Led_flash(void) { gpio_set_direction(GPIO_P01, GPIO_OUTPUT); gpio_toggle_pin(GPIO_P01); delay(100000); gpio_toggle_pin(GPIO_P01); }
esp_err_t rmt_set_pin(rmt_channel_t channel, rmt_mode_t mode, gpio_num_t gpio_num) { RMT_CHECK(channel < RMT_CHANNEL_MAX, RMT_CHANNEL_ERROR_STR, ESP_ERR_INVALID_ARG); RMT_CHECK(mode < RMT_MODE_MAX, RMT_MODE_ERROR_STR, ESP_ERR_INVALID_ARG); RMT_CHECK(((GPIO_IS_VALID_GPIO(gpio_num) && (mode == RMT_MODE_RX)) || (GPIO_IS_VALID_OUTPUT_GPIO(gpio_num) && (mode == RMT_MODE_TX))), RMT_GPIO_ERROR_STR, ESP_ERR_INVALID_ARG); PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[gpio_num], 2); if(mode == RMT_MODE_TX) { gpio_set_direction(gpio_num, GPIO_MODE_OUTPUT); gpio_matrix_out(gpio_num, RMT_SIG_OUT0_IDX + channel, 0, 0); } else { gpio_set_direction(gpio_num, GPIO_MODE_INPUT); gpio_matrix_in(gpio_num, RMT_SIG_IN0_IDX + channel, 0); } return ESP_OK; }
/*! * Turn on LCDIF power_en pin * * KEY_ROW5 (pin79) controls WVGA panel DISP pin, which is active high. * */ void lcdif_power_on(void) { /* turn on lcdif power on * (KEY_ROW5) ALT5: GPIO4_3 */ gpio_set_gpio(GPIO_PORT4, 3); gpio_set_direction(GPIO_PORT4, 3, GPIO_GDIR_OUTPUT); gpio_set_level(GPIO_PORT4, 3, GPIO_HIGH_LEVEL); }
void epdc_power_supply(void) { int i = 0; //EN : pmic_wakeup gpio2.14 gpio_set_gpio(GPIO_PORT2, 14); gpio_set_direction(GPIO_PORT2, 14, GPIO_GDIR_OUTPUT); gpio_set_level(GPIO_PORT2, 14, GPIO_HIGH_LEVEL); //CEN : pmic_vcom gpio2.3 gpio_set_gpio(GPIO_PORT2, 3); gpio_set_direction(GPIO_PORT2, 3, GPIO_GDIR_OUTPUT); gpio_set_level(GPIO_PORT2, 3, GPIO_HIGH_LEVEL); for (i = 0; i < 1000000; i++) __asm("nop"); }
/***************************************************************************//** * @brief main *******************************************************************************/ int main(void) { ad7768_dev *dev; gpio_device gpio_dev; adc_core core; ad7768_setup(&dev, default_init_param); /* Configure HDL */ gpio_set_direction(&dev->gpio_dev, GPIO_UP_FORMAT_1, GPIO_OUT); gpio_set_value(&dev->gpio_dev, GPIO_UP_FORMAT_1, 0); gpio_set_direction(&dev->gpio_dev, GPIO_UP_FORMAT_0, GPIO_OUT); gpio_set_value(&dev->gpio_dev, GPIO_UP_FORMAT_0, 0); gpio_set_direction(&dev->gpio_dev, GPIO_UP_CRC_ENABLE, GPIO_OUT); gpio_set_value(&dev->gpio_dev, GPIO_UP_CRC_ENABLE, dev->crc_sel ? 1 : 0); gpio_set_direction(&dev->gpio_dev, GPIO_UP_CRC_4_OR_16_N, GPIO_OUT); gpio_set_value(&dev->gpio_dev, GPIO_UP_CRC_4_OR_16_N, dev->crc_sel == AD7768_CRC_4 ? 1 : 0); gpio_dev.type = AXI_GPIO; gpio_dev.device_id = XPAR_AD7768_GPIO_DEVICE_ID; gpio_init(&gpio_dev); ad7768_evb_clear_status(&gpio_dev); if (ad7768_evb_verify_status(&gpio_dev)) printf("Interface errors\n"); else printf("Interface OK\n"); core.dmac_baseaddr = AD7768_DMA_BASEADDR; core.no_of_channels = 8; core.resolution = 24; printf("Capture samples...\n"); adc_capture(core, 1024, ADC_DDR_BASEADDR); printf("Capture done\n"); if (ad7768_evb_verify_status(&gpio_dev)) printf("Interface errors\n"); else printf("Interface OK\n"); return 0; }
/*! From obds * Audio Codec Power on */ void audio_codec_power_on (void) { #ifdef BOARD_SMART_DEVICE //CODEC PWR_EN, key_col12 gpio_set_gpio(GPIO_PORT4, 10); gpio_set_direction(GPIO_PORT4, 10, GPIO_GDIR_OUTPUT); gpio_set_level(GPIO_PORT4, 10, GPIO_HIGH_LEVEL); #endif }
void phy_rmii_configure_data_interface_pins(void) { // CRS_DRV to GPIO27 PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO27_U, FUNC_GPIO27_EMAC_RX_DV); // TXD0 to GPIO19 PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO19_U, FUNC_GPIO19_EMAC_TXD0); // TX_EN to GPIO21 PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO21_U, FUNC_GPIO21_EMAC_TX_EN); // TXD1 to GPIO22 PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO22_U, FUNC_GPIO22_EMAC_TXD1); // RXD0 to GPIO25 gpio_set_direction(25, GPIO_MODE_INPUT); // RXD1 to GPIO26 gpio_set_direction(26, GPIO_MODE_INPUT); // RMII CLK to GPIO0 gpio_set_direction(0, GPIO_MODE_INPUT); }
/* * Bypass the command sending infrastructure to allow * direct access to the what is sent to the chip */ static int cc2530_burst_write(void) { int ret; uint16_t i; unsigned char result; unsigned int timeout = DEFAULT_TIMEOUT; bool val; ret = gpio_set_direction(DATA_GPIO, GPIO_DIRECTION_OUT); if (ret) { fprintf(stderr, "failed to put gpio in output direction\n"); return ret; } send_byte(CMD_BURST_WR | HIBYTE(PROG_BLOCK_SIZE)); send_byte(LOBYTE(PROG_BLOCK_SIZE)); for (i = 0; i < PROG_BLOCK_SIZE; i++) send_byte(get_next_flash_byte()); ret = gpio_set_direction(DATA_GPIO, GPIO_DIRECTION_IN); if (ret) { fprintf(stderr, "failed to put gpio in input direction\n"); return ret; } gpio_get_value(DATA_GPIO, &val); while (val && timeout--) { for (i = 0; i < 8; i++) { gpio_set_value(CCLK_GPIO, 1); gpio_set_value(CCLK_GPIO, 0); } gpio_get_value(DATA_GPIO, &val); } if (!timeout) { fprintf(stderr, "timed out waiting for chip to be ready\n"); return -1; } read_byte(&result); return 0; }
void spdc_power_up(void) { int i = 0; gpio_set_gpio(GPIO_PORT1, 17); gpio_set_direction(GPIO_PORT1, 17, GPIO_GDIR_OUTPUT); gpio_set_level(GPIO_PORT1, 17, GPIO_LOW_LEVEL); /* Using the MAX17135 as the power supplier * Panel connector are using the AXT334124 * * Power Sequence: * VDD_Panel -> VEE -> VGG -> VDNS -> VDPS -> Vcom * * Pin Connections: * Name Pin# of MAX17135 Pin# of AXT334124 Comment * VDD_Panel: 3V15(from mainboard) 5,7 default enabled, comming from DCDC3V15 * VEE 6(DGVEE) 27,29 * VGG 4(DGVDD) 23,25 * VDNS 23(POS) 1,3 * VDPS 24(NEG) 2,4 * Vcom: 22(VCOM) 22,24 */ gpio_set_gpio(GPIO_PORT2, 7); gpio_set_direction(GPIO_PORT2, 7, GPIO_GDIR_OUTPUT); gpio_set_level(GPIO_PORT2, 7, GPIO_HIGH_LEVEL); //EN : pmic_wakeup gpio2.14 gpio_set_gpio(GPIO_PORT2, 14); gpio_set_direction(GPIO_PORT2, 14, GPIO_GDIR_OUTPUT); gpio_set_level(GPIO_PORT2, 14, GPIO_HIGH_LEVEL); //CEN : pmic_vcom gpio2.3 gpio_set_gpio(GPIO_PORT2, 3); gpio_set_direction(GPIO_PORT2, 3, GPIO_GDIR_OUTPUT); gpio_set_level(GPIO_PORT2, 3, GPIO_HIGH_LEVEL); while (i++ < 10000) __asm("nop"); gpio_set_gpio(GPIO_PORT1, 17); gpio_set_direction(GPIO_PORT1, 17, GPIO_GDIR_OUTPUT); gpio_set_level(GPIO_PORT1, 17, GPIO_HIGH_LEVEL); }
/*! * reset MIPI display */ void mipi_display_reset(void) { #ifdef BOARD_EVB /*pin29 of mipi connector for the LCD reset*/ gpio_set_gpio(GPIO_PORT5, 0); HW_IOMUXC_SW_PAD_CTL_PAD_EIM_WAIT_WR( BF_IOMUXC_SW_PAD_CTL_PAD_EIM_WAIT_HYS_V(ENABLED) | BF_IOMUXC_SW_PAD_CTL_PAD_EIM_WAIT_PUS_V(100K_OHM_PU) | BF_IOMUXC_SW_PAD_CTL_PAD_EIM_WAIT_PUE_V(PULL) | BF_IOMUXC_SW_PAD_CTL_PAD_EIM_WAIT_PKE_V(ENABLED) | BF_IOMUXC_SW_PAD_CTL_PAD_EIM_WAIT_ODE_V(DISABLED) | BF_IOMUXC_SW_PAD_CTL_PAD_EIM_WAIT_SPEED_V(100MHZ) | BF_IOMUXC_SW_PAD_CTL_PAD_EIM_WAIT_DSE_V(40_OHM) | BF_IOMUXC_SW_PAD_CTL_PAD_EIM_WAIT_SRE_V(SLOW)); gpio_set_direction(GPIO_PORT5, 0, GPIO_GDIR_OUTPUT); gpio_set_level(GPIO_PORT5, 0, GPIO_LOW_LEVEL); hal_delay_us(1000); gpio_set_level(GPIO_PORT5, 0, GPIO_HIGH_LEVEL); hal_delay_us(1000); #endif #ifdef BOARD_SABRE_AI /*binded with the board reset button*/ #endif #ifdef BOARD_SMART_DEVICE /*pin29 of mipi connector for the LCD reset*/ gpio_set_gpio(GPIO_PORT6, 11); HW_IOMUXC_SW_PAD_CTL_PAD_NAND_CS0_B_WR( BF_IOMUXC_SW_PAD_CTL_PAD_NAND_CS0_B_HYS_V(ENABLED) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_CS0_B_PUS_V(100K_OHM_PU) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_CS0_B_PUE_V(PULL) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_CS0_B_PKE_V(ENABLED) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_CS0_B_ODE_V(DISABLED) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_CS0_B_SPEED_V(100MHZ) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_CS0_B_DSE_V(40_OHM) | BF_IOMUXC_SW_PAD_CTL_PAD_NAND_CS0_B_SRE_V(SLOW)); gpio_set_direction(GPIO_PORT6, 11, GPIO_GDIR_OUTPUT); gpio_set_level(GPIO_PORT6, 11, GPIO_LOW_LEVEL); hal_delay_us(1000); gpio_set_level(GPIO_PORT6, 11, GPIO_HIGH_LEVEL); hal_delay_us(1000); #endif }
int main(void) { // Configure GPIOs: gpio_set_direction(IO_ADDRESS(GPIO1_BASE), 0x0000); // Switches gpio_set_direction(IO_ADDRESS(GPIO2_BASE), 0xffff); // LEDs // Configure the 7-segment displays: seg7_set_enabled_displays(IO_ADDRESS(SEG7_BASE), 0xff); seg7_set_value(IO_ADDRESS(SEG7_BASE), 0); // Set up the timer: timer_set(IO_ADDRESS(TIMER_BASE), SYSTEM_CLK_FREQ); // Print a startup message: uart_puts(IO_ADDRESS(UART_BASE), "The Potato Processor SHA256 Benchmark\n\r\n\r"); // Enable interrupts: potato_enable_irq(IRQ_TIMER); potato_enable_interrupts(); struct sha256_context context; // Prepare a block for hashing: uint32_t block[16]; uint8_t * block_ptr = (uint8_t *) block; block_ptr[0] = 'a'; block_ptr[1] = 'b'; block_ptr[2] = 'c'; sha256_pad_le_block(block_ptr, 3, 3); // Repeatedly hash the same data over and over again: while(true) { uint8_t hash[32]; sha256_reset(&context); sha256_hash_block(&context, block); sha256_get_hash(&context, hash); ++hashes_per_second; } return 0; }
/*! * set camera sensor to standby mode. * * @param enable: specify whether set camera sensor to standby mode * */ void sensor_standby(int32_t enable) { /* MX6DQ/SDL_SMART_DEVICE: setting to gpio1_16, power down high active */ BW_IOMUXC_SW_MUX_CTL_PAD_SD1_DATA0_MUX_MODE(BV_IOMUXC_SW_MUX_CTL_PAD_SD1_DATA0_MUX_MODE__ALT5); gpio_set_direction(GPIO_PORT1, 16, GPIO_GDIR_OUTPUT); if (enable) gpio_set_level(GPIO_PORT1, 16, GPIO_HIGH_LEVEL); else gpio_set_level(GPIO_PORT1, 16, GPIO_LOW_LEVEL); }
static int checkOverrideGpio() { #ifdef BOOTWIFI_OVERRIDE_GPIO gpio_pad_select_gpio(BOOTWIFI_OVERRIDE_GPIO); gpio_set_direction(BOOTWIFI_OVERRIDE_GPIO, GPIO_MODE_INPUT); gpio_set_pull_mode(BOOTWIFI_OVERRIDE_GPIO, GPIO_PULLDOWN_ONLY); return gpio_get_level(BOOTWIFI_OVERRIDE_GPIO); #else return 0; // If no boot override, return false #endif } // checkOverrideGpio