Example #1
0
static int cosmo_gps_gpio_probe(struct platform_device *pdev)
{
	int retval = 0;

	printk(KERN_INFO "cosmo_gps_gpio_probe\n");

	omap_mux_init_gpio(GPIO_GPS_PWR_ON,  OMAP_PIN_OUTPUT);
	omap_mux_init_gpio(GPIO_GPS_RESET_N, OMAP_PIN_OUTPUT);
	omap_mux_init_gpio(GPIO_GPS_LNA_SD, OMAP_PIN_OUTPUT);
	retval = gpio_request(GPIO_GPS_PWR_ON,  "GPS power on GPIO");
	if (retval)
	{
		printk(KERN_ERR "cosmo_gps_gpio_probe: GPIO %d is already used!\n", GPIO_GPS_PWR_ON);
		return retval;
	}
	
	retval = gpio_request(GPIO_GPS_RESET_N, "GPS reset GPIO");
	if (retval)
	{
		printk(KERN_ERR "cosmo_gps_gpio_probe: GPIO %d is already used!\n", GPIO_GPS_RESET_N);
		return retval;
	}

		retval = gpio_request(GPIO_GPS_LNA_SD, "GPS extend LNA GPIO");
		if (retval)
		{
			printk(KERN_ERR "cosmo_gps_gpio_probe: GPIO %d is already used!\n", GPIO_GPS_LNA_SD);
			return retval;
		}

	retval = device_create_file(&pdev->dev, &dev_attr_reset);
	if (retval)
		goto error;
	
	retval = device_create_file(&pdev->dev, &dev_attr_poweron);
	if (retval)
		goto error;

	return 0;

error:
	printk(KERN_ERR "cosmo_gps_gpio_probe: Cannot create file desc.!\n");
	device_remove_file(&pdev->dev, &dev_attr_reset);
	device_remove_file(&pdev->dev, &dev_attr_poweron);
	
	return retval;
}
static void config_mux_mcbsp3(void)
{
	/*Mux setting for GPIO164 McBSP3 */
#ifdef CONFIG_MACH_OMAP_FST_OMAP3_127x
	omap_mux_init_gpio(McBSP3_BT_GPIO, OMAP_PIN_OUTPUT);
#endif
	return;
}
Example #3
0
static void __init board_smc91x_init(void)
{
	if (is_gpmc_muxed())
		board_smc91x_data.flags |= GPMC_MUX_ADD_DATA;

	omap_mux_init_gpio(board_smc91x_data.gpio_irq, OMAP_PIN_INPUT);
	gpmc_smc91x_init(&board_smc91x_data);
}
static void __init am3517_evm_display_init(void)
{
	int r;

	omap_mux_init_gpio(LCD_PANEL_PWR, OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_gpio(LCD_PANEL_BKLIGHT_PWR, OMAP_PIN_INPUT_PULLDOWN);
	omap_mux_init_gpio(LCD_PANEL_PWM, OMAP_PIN_INPUT_PULLDOWN);

	r = gpio_request_array(am3517_evm_dss_gpios,
			       ARRAY_SIZE(am3517_evm_dss_gpios));
	if (r) {
		printk(KERN_ERR "failed to get DSS panel control GPIOs\n");
		return;
	}

	printk(KERN_INFO "Display initialized successfully\n");
}
Example #5
0
static int hub_gps_gpio_probe(struct platform_device *pdev)
{
	int retval = 0;

	printk(KERN_INFO "hub_gps_gpio_probe\n");

	omap_mux_init_gpio(GPIO_GPS_PWR_ON,  OMAP_PIN_OUTPUT);
	omap_mux_init_gpio(GPIO_GPS_RESET_N, OMAP_PIN_OUTPUT);

	retval = gpio_request(GPIO_GPS_PWR_ON,  "GPS power on GPIO");
	if (retval)
	{
		printk(KERN_ERR "hub_gps_gpio_probe: GPIO %d is already used!\n", GPIO_GPS_PWR_ON);
		return retval;
	}
	
	retval = gpio_request(GPIO_GPS_RESET_N, "GPS reset GPIO");
	if (retval)
	{
		printk(KERN_ERR "hub_gps_gpio_probe: GPIO %d is already used!\n", GPIO_GPS_RESET_N);
		return retval;
	}

	retval = device_create_file(&pdev->dev, &dev_attr_reset);
	if (retval)
		goto error;
	
	retval = device_create_file(&pdev->dev, &dev_attr_poweron);
	if (retval)
		goto error;

  /* LGE_CHANGE_S, [email protected], 2011-05-08, after root -> system, fix for first try dead  */		
	gpio_direction_output(GPIO_GPS_PWR_ON, 0);	 
	gpio_direction_output(GPIO_GPS_RESET_N, 1);	
	//gpio_direction_output(GPIO_GPS_RESET_N, 0);
	/* LGE_CHANGE_E, [email protected], 2011-05-08, after root -> system, fix for first try dead  */	
	
	return 0;

error:
	printk(KERN_ERR "hub_gps_gpio_probe: Cannot create file desc.!\n");
	device_remove_file(&pdev->dev, &dev_attr_reset);
	device_remove_file(&pdev->dev, &dev_attr_poweron);
	
	return retval;
}
static void __init am3517_evm_init(void)
{
	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);

	am3517_evm_i2c_init();
	platform_add_devices(am3517_evm_devices,
				ARRAY_SIZE(am3517_evm_devices));

	omap_serial_init();

	/* Configure GPIO for EHCI port */
	omap_mux_init_gpio(57, OMAP_PIN_OUTPUT);
	usb_ehci_init(&ehci_pdata);
	am3517_evm_hecc_init(&am3517_evm_hecc_pdata);

	clk_add_alias("master", "dm644x_ccdc", "master",
			&vpfe_capture_dev.dev);
	clk_add_alias("slave", "dm644x_ccdc", "slave",
			&vpfe_capture_dev.dev);

	/* DSS */
	am3517_evm_display_init();

	/* RTC - S35390A */
	am3517_evm_rtc_init();

	i2c_register_board_info(1, am3517evm_i2c1_boardinfo,
				ARRAY_SIZE(am3517evm_i2c1_boardinfo));
	/*Ethernet*/
	am3517_evm_ethernet_init(&am3517_evm_emac_pdata);

	/* MUSB */
	am3517_evm_musb_init();

	/* TSC 2004 */
	omap_mux_init_gpio(65, OMAP_PIN_INPUT_PULLUP);
	am3517evm_tsc_i2c_boardinfo[0].irq = gpio_to_irq(GPIO_TSC2004_IRQ);
	i2c_register_board_info(1, am3517evm_tsc_i2c_boardinfo,
				ARRAY_SIZE(am3517evm_tsc_i2c_boardinfo));

	/* Init TCA6416 keypad */
	tca6416_keypad_init_irq();

	/* MMC init function */
	omap2_hsmmc_init(mmc);
}
Example #7
0
static void __init omap_h4_init(void)
{
	omap2420_mux_init(board_mux, OMAP_PACKAGE_ZAF);

	omap_board_config = h4_config;
	omap_board_config_size = ARRAY_SIZE(h4_config);

	/*
	 * Make sure the serial ports are muxed on at this point.
	 * You have to mux them off in device drivers later on
	 * if not needed.
	 */

#if defined(CONFIG_KEYBOARD_OMAP) || defined(CONFIG_KEYBOARD_OMAP_MODULE)
	omap_mux_init_gpio(88, OMAP_PULL_ENA | OMAP_PULL_UP);
	omap_mux_init_gpio(89, OMAP_PULL_ENA | OMAP_PULL_UP);
	omap_mux_init_gpio(124, OMAP_PULL_ENA | OMAP_PULL_UP);
	omap_mux_init_signal("mcbsp2_dr.gpio_11", OMAP_PULL_ENA | OMAP_PULL_UP);
	if (omap_has_menelaus()) {
		omap_mux_init_signal("sdrc_a14.gpio0",
			OMAP_PULL_ENA | OMAP_PULL_UP);
		omap_mux_init_signal("vlynq_rx0.gpio_15", 0);
		omap_mux_init_signal("gpio_98", 0);
		row_gpios[5] = 0;
		col_gpios[2] = 15;
		col_gpios[6] = 18;
	} else {
		omap_mux_init_signal("gpio_96", OMAP_PULL_ENA | OMAP_PULL_UP);
		omap_mux_init_signal("gpio_100", 0);
		omap_mux_init_signal("gpio_98", 0);
	}
	omap_mux_init_signal("gpio_90", 0);
	omap_mux_init_signal("gpio_91", 0);
	omap_mux_init_signal("gpio_36", 0);
	omap_mux_init_signal("mcbsp2_clkx.gpio_12", 0);
	omap_mux_init_signal("gpio_97", 0);
#endif

	i2c_register_board_info(1, h4_i2c_board_info,
			ARRAY_SIZE(h4_i2c_board_info));

	platform_add_devices(h4_devices, ARRAY_SIZE(h4_devices));
	omap2_usbfs_init(&h4_usb_config);
	omap_serial_init();
	h4_init_flash();
}
static void __init omap3_beagle_init_rev(void)
{
	int ret;
	u16 beagle_rev = 0;

	omap_mux_init_gpio(171, OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_gpio(172, OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_gpio(173, OMAP_PIN_INPUT_PULLUP);

	ret = gpio_request_array(omap3_beagle_rev_gpios,
				 ARRAY_SIZE(omap3_beagle_rev_gpios));
	if (ret < 0) {
		printk(KERN_ERR "Unable to get revision detection GPIO pins\n");
		omap3_beagle_version = OMAP3BEAGLE_BOARD_UNKN;
		return;
	}

	beagle_rev = gpio_get_value(171) | (gpio_get_value(172) << 1)
			| (gpio_get_value(173) << 2);

	gpio_free_array(omap3_beagle_rev_gpios,
			ARRAY_SIZE(omap3_beagle_rev_gpios));

	switch (beagle_rev) {
	case 7:
		printk(KERN_INFO "OMAP3 Beagle Rev: Ax/Bx\n");
		omap3_beagle_version = OMAP3BEAGLE_BOARD_AXBX;
		break;
	case 6:
		printk(KERN_INFO "OMAP3 Beagle Rev: C1/C2/C3\n");
		omap3_beagle_version = OMAP3BEAGLE_BOARD_C1_3;
		break;
	case 5:
		printk(KERN_INFO "OMAP3 Beagle Rev: C4\n");
		omap3_beagle_version = OMAP3BEAGLE_BOARD_C4;
		break;
	case 0:
		printk(KERN_INFO "OMAP3 Beagle Rev: xM\n");
		omap3_beagle_version = OMAP3BEAGLE_BOARD_XM;
		break;
	default:
		printk(KERN_INFO "OMAP3 Beagle Rev: unknown %hd\n", beagle_rev);
		omap3_beagle_version = OMAP3BEAGLE_BOARD_UNKN;
	}
}
static void __init omap3_evm_init(void)
{
	omap3_evm_get_revision();
	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);

	omap3_evm_i2c_init();

	platform_add_devices(omap3_evm_devices, ARRAY_SIZE(omap3_evm_devices));

	spi_register_board_info(omap3evm_spi_board_info,
				ARRAY_SIZE(omap3evm_spi_board_info));

	omap_serial_init();

	if (get_omap3_evm_rev() >= OMAP3EVM_BOARD_GEN_2) {
		/* enable EHCI VBUS using GPIO22 */
		omap_mux_init_gpio(22, OMAP_PIN_INPUT_PULLUP);
		gpio_request(OMAP3_EVM_EHCI_VBUS, "enable EHCI VBUS");
		gpio_direction_output(OMAP3_EVM_EHCI_VBUS, 0);
		gpio_set_value(OMAP3_EVM_EHCI_VBUS, 1);

		/* Select EHCI port on main board */
		omap_mux_init_gpio(61, OMAP_PIN_INPUT_PULLUP);
		gpio_request(OMAP3_EVM_EHCI_SELECT, "select EHCI port");
		gpio_direction_output(OMAP3_EVM_EHCI_SELECT, 0);
		gpio_set_value(OMAP3_EVM_EHCI_SELECT, 0);

		/* setup EHCI phy reset config */
		omap_mux_init_gpio(21, OMAP_PIN_INPUT_PULLUP);
		ehci_pdata.reset_gpio_port[1] = 21;

		/* EVM REV >= E can supply 500mA with EXTVBUS programming */
		musb_board_data.power = 500;
		musb_board_data.extvbus = 1;
	} else {
		/* setup EHCI phy reset on MDC */
		omap_mux_init_gpio(135, OMAP_PIN_OUTPUT);
		ehci_pdata.reset_gpio_port[1] = 135;
	}
	usb_musb_init(&musb_board_data);
	usb_ehci_init(&ehci_pdata);
	ads7846_dev_init();
	omap3evm_init_smsc911x();
	omap3_evm_display_init();
}
static void __init omap4_panda_display_init(void)
{

	omap_display_init(&omap4_panda_dss_data);

	/*
	 * OMAP4460SDP/Blaze and OMAP4430 ES2.3 SDP/Blaze boards and
	 * later have external pull up on the HDMI I2C lines
	 */
	if (cpu_is_omap446x() || omap_rev() > OMAP4430_REV_ES2_2)
		omap_hdmi_init(OMAP_HDMI_SDA_SCL_EXTERNAL_PULLUP);
	else
		omap_hdmi_init(0);

	omap_mux_init_gpio(HDMI_GPIO_LS_OE, OMAP_PIN_OUTPUT);
	omap_mux_init_gpio(HDMI_GPIO_CT_CP_HPD, OMAP_PIN_OUTPUT);
	omap_mux_init_gpio(HDMI_GPIO_HPD, OMAP_PIN_INPUT_PULLDOWN);
}
Example #11
0
static int beagle_twl_gpio_setup(struct device *dev,
		unsigned gpio, unsigned ngpio)
{
	int r;

	if (beagle_config.mmc1_gpio_wp != -EINVAL)
		omap_mux_init_gpio(beagle_config.mmc1_gpio_wp, OMAP_PIN_INPUT);
	mmc[0].gpio_wp = beagle_config.mmc1_gpio_wp;
	/* gpio + 0 is "mmc0_cd" (input/IRQ) */
	mmc[0].gpio_cd = gpio + 0;
	omap2_hsmmc_init(mmc);

	/* link regulators to MMC adapters */
	beagle_vmmc1_supply.dev = mmc[0].dev;
	beagle_vsim_supply.dev = mmc[0].dev;

	/*
	 * TWL4030_GPIO_MAX + 0 == ledA, EHCI nEN_USB_PWR (out, XM active
	 * high / others active low)
	 * DVI reset GPIO is different between beagle revisions
	 */
	/* Valid for all -xM revisions */
	if (cpu_is_omap3630()) {
		/*
		 * gpio + 1 on Xm controls the TFP410's enable line (active low)
		 * gpio + 2 control varies depending on the board rev as below:
		 * P7/P8 revisions(prototype): Camera EN
		 * A2+ revisions (production): LDO (DVI, serial, led blocks)
		 */
		r = gpio_request_one(gpio + 1, GPIOF_OUT_INIT_LOW,
				     "nDVI_PWR_EN");
		if (r)
			pr_err("%s: unable to configure nDVI_PWR_EN\n",
				__func__);
		r = gpio_request_one(gpio + 2, GPIOF_OUT_INIT_HIGH,
				     "DVI_LDO_EN");
		if (r)
			pr_err("%s: unable to configure DVI_LDO_EN\n",
				__func__);
	} else {
		/*
		 * REVISIT: need ehci-omap hooks for external VBUS
		 * power switch and overcurrent detect
		 */
		if (gpio_request_one(gpio + 1, GPIOF_IN, "EHCI_nOC"))
			pr_err("%s: unable to configure EHCI_nOC\n", __func__);
	}
	beagle_dvi_device.reset_gpio = beagle_config.reset_gpio;

	gpio_request_one(gpio + TWL4030_GPIO_MAX, beagle_config.usb_pwr_level,
			"nEN_USB_PWR");

	/* TWL4030_GPIO_MAX + 1 == ledB, PMU_STAT (out, active low LED) */
	gpio_leds[2].gpio = gpio + TWL4030_GPIO_MAX + 1;

	return 0;
}
Example #12
0
// Anvoi, 2011/12/14, Porting Light sensor driver to ICS
static void omap4_als_init(void)
{
#ifdef CONFIG_INPUT_MAX44007
        /* max44007 gpio */
        printk("MAX44007: Pulling up IRQ line\n");
        omap_mux_init_gpio(GPIO_MAX44007_IRQ, \
                OMAP_PIN_INPUT_PULLUP);
#endif
}
static void __init omap_zoom_init(void)
{
	omap3_mux_init(board_mux, OMAP_PACKAGE_CBP);
	zoom_peripherals_init();
	zoom_debugboard_init();

	omap_mux_init_gpio(64, OMAP_PIN_OUTPUT);
	usb_ehci_init(&ehci_pdata);
}
Example #14
0
static void __init omap3_evm_init(void)
{
	omap3_evm_get_revision();
	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);

	omap3_evm_i2c_init();

	platform_add_devices(omap3_evm_devices, ARRAY_SIZE(omap3_evm_devices));

	spi_register_board_info(omap3evm_spi_board_info,
				ARRAY_SIZE(omap3evm_spi_board_info));

	omap_serial_init();
#ifdef CONFIG_NOP_USB_XCEIV
	/* OMAP3EVM uses ISP1504 phy and so register nop transceiver */
	usb_nop_xceiv_register();
#endif
	if (get_omap3_evm_rev() >= OMAP3EVM_BOARD_GEN_2) {
		/* enable EHCI VBUS using GPIO22 */
		omap_mux_init_gpio(22, OMAP_PIN_INPUT_PULLUP);
		gpio_request(OMAP3_EVM_EHCI_VBUS, "enable EHCI VBUS");
		gpio_direction_output(OMAP3_EVM_EHCI_VBUS, 0);
		gpio_set_value(OMAP3_EVM_EHCI_VBUS, 1);

		/* Select EHCI port on main board */
		omap_mux_init_gpio(61, OMAP_PIN_INPUT_PULLUP);
		gpio_request(OMAP3_EVM_EHCI_SELECT, "select EHCI port");
		gpio_direction_output(OMAP3_EVM_EHCI_SELECT, 0);
		gpio_set_value(OMAP3_EVM_EHCI_SELECT, 0);

		/* setup EHCI phy reset config */
		omap_mux_init_gpio(21, OMAP_PIN_INPUT_PULLUP);
		ehci_pdata.reset_gpio_port[1] = 21;

	} else {
		/* setup EHCI phy reset on MDC */
		omap_mux_init_gpio(135, OMAP_PIN_OUTPUT);
		ehci_pdata.reset_gpio_port[1] = 135;
	}
	usb_musb_init();
	usb_ehci_init(&ehci_pdata);
	ads7846_dev_init();
	omap3evm_init_smsc911x();
}
Example #15
0
static int tr16c0_archos_demux_i2c(int demux)
{
	//int v = omap_readl(0x4a100604);

	pr_debug("%s:%d\n", __func__, demux);

	if (demux) {
		// disable irq pull up.
		omap_mux_init_gpio(irq_gpio, OMAP_PIN_INPUT);

		// switch back i2c lines to gpio mode
		gpio_request(i2c4_scl_gpio, "i2c4_scl_gpio");
		gpio_request(i2c4_sda_gpio, "i2c4_sda_gpio");

		omap_mux_init_gpio(i2c4_scl_gpio, OMAP_PIN_OUTPUT);
		omap_mux_init_gpio(i2c4_sda_gpio, OMAP_PIN_OUTPUT);

		gpio_direction_output(i2c4_scl_gpio, 0);
		gpio_direction_output(i2c4_sda_gpio, 0);

		// force low level.
		gpio_set_value(i2c4_scl_gpio, 0);
		gpio_set_value(i2c4_sda_gpio, 0);

		// disable omap internal pull ups
		// omap_writel(v & ~(1 << 28), 0x4a100604);
	} else {
		// enable omap internal pull ups
		// omap_writel(v | (1 << 28), 0x4a100604);

		// put back irq pull up.
		omap_mux_init_gpio(irq_gpio, OMAP_PIN_INPUT_PULLUP | OMAP_PIN_OFF_WAKEUPENABLE);

		gpio_free(i2c4_scl_gpio);
		gpio_free(i2c4_sda_gpio);

		// mux back to i2c lines.
		omap_mux_init_signal("i2c4_scl.i2c4_scl", OMAP_PIN_INPUT);
		omap_mux_init_signal("i2c4_sda.i2c4_sda", OMAP_PIN_INPUT);
	}

	return 0;
}
static void ctw6120_dev_init(void)
{
	if (gpio_request(VAR_SOM_OM3X_TS_GPIO, "CTW6120 data") < 0)
		printk(KERN_ERR "can't get CTW6120 data GPIO\n");

	omap_mux_init_gpio(VAR_SOM_OM3X_TS_GPIO, OMAP_PIN_INPUT);
	gpio_direction_input(VAR_SOM_OM3X_TS_GPIO);


}
Example #17
0
static void __init am3517_evm_display_init(void)
{
	int r;

	omap_mux_init_gpio(LCD_PANEL_PWR, OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_gpio(LCD_PANEL_BKLIGHT_PWR, OMAP_PIN_INPUT_PULLDOWN);
	omap_mux_init_gpio(LCD_PANEL_PWM, OMAP_PIN_INPUT_PULLDOWN);
	/*
	 * Enable GPIO 182 = LCD Backlight Power
	 */
	r = gpio_request(LCD_PANEL_BKLIGHT_PWR, "lcd_backlight_pwr");
	if (r) {
		printk(KERN_ERR "failed to get lcd_backlight_pwr\n");
		return;
	}
	gpio_direction_output(LCD_PANEL_BKLIGHT_PWR, 1);
	/*
	 * Enable GPIO 181 = LCD Panel PWM
	 */
	r = gpio_request(LCD_PANEL_PWM, "lcd_pwm");
	if (r) {
		printk(KERN_ERR "failed to get lcd_pwm\n");
		goto err_1;
	}
	gpio_direction_output(LCD_PANEL_PWM, 1);
	/*
	 * Enable GPIO 176 = LCD Panel Power enable pin
	 */
	r = gpio_request(LCD_PANEL_PWR, "lcd_panel_pwr");
	if (r) {
		printk(KERN_ERR "failed to get lcd_panel_pwr\n");
		goto err_2;
	}
	gpio_direction_output(LCD_PANEL_PWR, 1);

	printk(KERN_INFO "Display initialized successfully\n");
	return;

err_2:
	gpio_free(LCD_PANEL_PWM);
err_1:
	gpio_free(LCD_PANEL_BKLIGHT_PWR);
}
Example #18
0
static void __init omap_msecure_init(void)
{
	int err;
	/* setup msecure line as GPIO for RTC accesses */
	omap_mux_init_gpio(GPIO_MSECURE, OMAP_PIN_OUTPUT);
	err = gpio_request_one(GPIO_MSECURE, GPIOF_OUT_INIT_HIGH, "msecure");
	if (err < 0)
		pr_err("Failed to request GPIO %d, error %d\n",
			GPIO_MSECURE, err);
}
void __init omap4_panda_display_init(void)
{
	int r;

	r = omap4_panda_dvi_init();
	if (r)
		pr_err("error initializing panda DVI\n");

	omap_display_init(&omap4_panda_dss_data);

	if (cpu_is_omap446x() || omap_rev() > OMAP4430_REV_ES2_2)
		omap_hdmi_init(OMAP_HDMI_SDA_SCL_EXTERNAL_PULLUP);
	else
		omap_hdmi_init(0);

	omap_mux_init_gpio(HDMI_GPIO_LS_OE, OMAP_PIN_OUTPUT);
	omap_mux_init_gpio(HDMI_GPIO_CT_CP_HPD, OMAP_PIN_OUTPUT);
	omap_mux_init_gpio(HDMI_GPIO_HPD, OMAP_PIN_INPUT_PULLDOWN);
}
Example #20
0
static void omap_4430sdp_display_init(void)
{
	int r;

	/* Enable LCD2 by default (instead of Pico DLP) */
	r = gpio_request_one(DISPLAY_SEL_GPIO, GPIOF_OUT_INIT_HIGH,
			"display_sel");
	if (r)
		pr_err("%s: Could not get display_sel GPIO\n", __func__);

	sdp4430_lcd_init();
	sdp4430_hdmi_mux_init();
	sdp4430_picodlp_init();
	omap_display_init(&sdp4430_dss_data);

	omap_mux_init_gpio(HDMI_GPIO_LS_OE, OMAP_PIN_OUTPUT);
	omap_mux_init_gpio(HDMI_GPIO_CT_CP_HPD, OMAP_PIN_OUTPUT);
	omap_mux_init_gpio(HDMI_GPIO_HPD, OMAP_PIN_INPUT_PULLDOWN);
}
Example #21
0
static void omap4_tablet_wifi_mux_init(void)
{
	omap_mux_init_gpio(GPIO_WIFI_IRQ, OMAP_PIN_INPUT |
				OMAP_PIN_OFF_WAKEUPENABLE);
	omap_mux_init_gpio(GPIO_WIFI_PMENA, OMAP_PIN_OUTPUT);
        omap_mux_init_gpio(GPIO_WIFI_PWEN, OMAP_PIN_OUTPUT);
	omap_mux_init_signal("uart2_cts.sdmmc3_clk",
				OMAP_MUX_MODE1 | OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_signal("uart2_rts.sdmmc3_cmd",
				OMAP_MUX_MODE1 | OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_signal("uart2_rx.sdmmc3_dat0",
				OMAP_MUX_MODE1 | OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_signal("uart2_tx.sdmmc3_dat1",
				OMAP_MUX_MODE1 | OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_signal("abe_mcbsp1_dx.sdmmc3_dat2",
				OMAP_MUX_MODE1 | OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_signal("abe_mcbsp1_fsx.sdmmc3_dat3",
				OMAP_MUX_MODE1 | OMAP_PIN_INPUT_PULLUP);
}
Example #22
0
static void __init rx51_init_tsc2005(void)
{
	int r;

	omap_mux_init_gpio(RX51_TSC2005_RESET_GPIO, OMAP_PIN_OUTPUT);
	omap_mux_init_gpio(RX51_TSC2005_IRQ_GPIO, OMAP_PIN_INPUT_PULLUP);

	r = gpio_request_array(rx51_tsc2005_gpios,
			       ARRAY_SIZE(rx51_tsc2005_gpios));
	if (r < 0) {
		printk(KERN_ERR "tsc2005 board initialization failed\n");
		tsc2005_pdata.esd_timeout_ms = 0;
		return;
	}

	tsc2005_pdata.set_reset = rx51_tsc2005_set_reset;
	rx51_peripherals_spi_board_info[RX51_SPI_TSC2005].irq =
				gpio_to_irq(RX51_TSC2005_IRQ_GPIO);
}
/**
 * @brief omap3stalkerdc_gpio_config - GPIO configuration for
 *                          GPIO 98
 *
 * @return result of operation - 0 is success
 */
static int omap3stalkerdc_gpio_config(void)
{
	omap_mux_init_gpio(GPIO_VID_DEC_RES, OMAP_PIN_OUTPUT);
	if (gpio_request(GPIO_VID_DEC_RES, "vid-dec reset") < 0) {
		printk(KERN_ERR "failed to get GPIO_VID_DEC_RES\n");
		return -EINVAL;
	}
	gpio_direction_output(GPIO_VID_DEC_RES, 1);
	return 0;
}
Example #24
0
static void __init omap3_beagle_init(void)
{
	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
	omap3_beagle_init_rev();

	if (gpio_is_valid(beagle_config.mmc1_gpio_wp))
		omap_mux_init_gpio(beagle_config.mmc1_gpio_wp, OMAP_PIN_INPUT);
	mmc[0].caps = beagle_config.mmc_caps;
	omap_hsmmc_init(mmc);

	omap3_beagle_i2c_init();

	gpio_buttons[0].gpio = beagle_config.usr_button_gpio;

	platform_add_devices(omap3_beagle_devices,
			ARRAY_SIZE(omap3_beagle_devices));
	if (gpio_is_valid(beagle_config.dvi_pd_gpio))
		omap_mux_init_gpio(beagle_config.dvi_pd_gpio, OMAP_PIN_OUTPUT);
	omap_display_init(&beagle_dss_data);

	omap_serial_init();
	omap_sdrc_init(mt46h32m32lf6_sdrc_params,
				  mt46h32m32lf6_sdrc_params);

	usb_bind_phy("musb-hdrc.0.auto", 0, "twl4030_usb");
	usb_musb_init(NULL);

	usbhs_init(&usbhs_bdata);

	board_nand_init(omap3beagle_nand_partitions,
			ARRAY_SIZE(omap3beagle_nand_partitions), NAND_CS,
			NAND_BUSWIDTH_16, NULL);
	omap_twl4030_audio_init("omap3beagle", NULL);

	/* Ensure msecure is mux'd to be able to set the RTC. */
	omap_mux_init_signal("sys_drm_msecure", OMAP_PIN_OFF_OUTPUT_HIGH);

	/* Ensure SDRC pins are mux'd for self-refresh */
	omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
	omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);

	pwm_add_table(pwm_lookup, ARRAY_SIZE(pwm_lookup));
}
static void omap4_tablet_wifi_mux_init(void)
{
	omap_mux_init_gpio(GPIO_WIFI_IRQ, OMAP_PIN_INPUT |
				OMAP_PIN_OFF_WAKEUPENABLE);
	omap_mux_init_gpio(GPIO_WIFI_PMENA, OMAP_PIN_OUTPUT);

	omap_mux_init_signal("sdmmc5_cmd.sdmmc5_cmd",
				OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_signal("sdmmc5_clk.sdmmc5_clk",
				OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_signal("sdmmc5_dat0.sdmmc5_dat0",
				OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_signal("sdmmc5_dat1.sdmmc5_dat1",
				OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_signal("sdmmc5_dat2.sdmmc5_dat2",
				OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
	omap_mux_init_signal("sdmmc5_dat3.sdmmc5_dat3",
				OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP);
}
static void remux_regulator_gpio(int gpio)
{
	switch (gpio) {
	default:
		omap_mux_init_gpio(gpio, OMAP_PIN_INPUT|OMAP_PIN_OUTPUT);
		break;

	case 104:
		omap_mux_init_signal("gpmc_ncs7.gpio_104",
				OMAP_PIN_INPUT|OMAP_PIN_OUTPUT);
		break;

	case GPIO_VCC_PWRON:
	case GPIO_1V8_PWRON:
		/* These signals control voltages that are needed after warm reset,
		   make sure, they are pulled high */
		omap_mux_init_gpio(gpio, OMAP_PIN_INPUT_PULLUP|OMAP_PIN_OUTPUT);
		break;
	}
}
static void fidji_mmc_init(void)
{
	u32 reg;
	/* MMC2 CD and CLKIN */
	omap_mux_init_signal("sdmmc2_clkin",
			OMAP_PIN_INPUT);

	/*
	 * MMC2 has been designed to be used with a level shifter
	 * but we are NOT using anyone.
	 */
	reg = omap_ctrl_readl(OMAP343X_CONTROL_DEVCONF1);
	reg |= OMAP2_MMCSDIO2ADPCLKISEL;
	omap_ctrl_writel(reg, OMAP343X_CONTROL_DEVCONF1);

	/* MMC1 CD and WP */
	omap_mux_init_gpio(GPIO_MMC1_CD, OMAP_PIN_INPUT);
	omap_mux_init_gpio(GPIO_MMC1_WP, OMAP_PIN_INPUT);
	omap2_hsmmc_init(mmc_rev2);
}
Example #28
0
static void __init rhino_init(void)
{
	/* Initialize MUX overrides */
	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);

	/* Initialize I2C lines */
	rhino_i2c_init();
	
	/* Add all platform devices */
	platform_add_devices(rhino_devices, ARRAY_SIZE(rhino_devices));

	/* Initialize the serial device */
	omap_serial_init();
	
	/* Configure GPIO for EHCI port */
	omap_mux_init_gpio(57, OMAP_PIN_OUTPUT);
	usb_ehci_init(&ehci_pdata);
	rhino_hecc_init(&rhino_hecc_pdata);

	/* Initialize the NAND flash */
	board_nand_init(rhino_nand_partitions, ARRAY_SIZE(rhino_nand_partitions), 0, NAND_BUSWIDTH_16);

	/* Configure the RTC */
	omap_mux_init_gpio(GPIO_RTCDS1390_IRQ, OMAP_PIN_INPUT_PULLDOWN);
	if (gpio_request(GPIO_RTCDS1390_IRQ, "rtcs35390a-irq") < 0)
		printk(KERN_WARNING "failed to request GPIO#%d\n", GPIO_RTCDS1390_IRQ);
	if (gpio_direction_input(GPIO_RTCDS1390_IRQ))
		printk(KERN_WARNING "GPIO#%d cannot be configured as input\n", GPIO_RTCDS1390_IRQ);
	rhino_spi_board_info[0].irq = gpio_to_irq(GPIO_RTCDS1390_IRQ);
	
	/* Initialize SPI devices */
	rhino_spi_init();
		
	/* Initialize Ethernet */
	rhino_ethernet_init(&rhino_emac_pdata);

	rhino_musb_init();

	/* MMC init function */
	omap2_hsmmc_init(mmc);
}
/* Touchscreen */
static void omap_fidji_rohm_bu21023_init(void)
{
	int ret;

	omap_mux_init_gpio(GPIO_TS_PENIRQ, OMAP_PIN_INPUT_PULLUP);
	ret = gpio_request(GPIO_TS_PENIRQ, "ROHM BU21023_pen_down");
	if (ret < 0) {
		printk(KERN_ERR "Failed to request GPIO %d for ""ROHM BU21023 pen down IRQ\n", GPIO_TS_PENIRQ);
		return;
	}
	gpio_direction_input(GPIO_TS_PENIRQ);
}
Example #30
0
static void __init omap3_beagle_init(void)
{
	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
	omap3_beagle_i2c_init();
	printk(KERN_INFO "*************INIT I2C**************\n");
	platform_add_devices(omap3_beagle_devices,
			ARRAY_SIZE(omap3_beagle_devices));
	omap_serial_init();
	
//	omap_mux_init_gpio(170, OMAP_PIN_INPUT);
//	gpio_request(170, "DVI_nPD");
//	/* REVISIT leave DVI powered down until it's needed ... */
//	gpio_direction_output(170, true);
	
//added by haolong to fix reset io of smsc9514, 2012/04/10-------
	printk(KERN_ERR "#########pulldown gpio 40#######\n");
	if(omap_mux_init_gpio(40, OMAP_PIN_OUTPUT) < 0)
	{
			printk(KERN_ERR "Unable to mux HUB_RST\n");
	}
	if (gpio_request(40, "HUB_RST") < 0) {
			printk(KERN_ERR "Unable to get HUB_RST GPIO\n");
	}
	gpio_direction_output(40, 0);
//-------------------------------------------------------

	usb_musb_init();
	usb_ehci_init(&ehci_pdata);
	omap3beagle_flash_init();

	/* Ensure SDRC pins are mux'd for self-refresh */
	omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
	omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);
//--------------------------20111121 modified by haolong---------------------
//	if (gpio_request(129, "DVI reset") < 0) {
//		printk(KERN_ERR "Unable to get DVI reset GPIO\n");
//		return;
//	}

//	gpio_direction_output(129, 1);
//------------------------------------------------------------------------
//2012/04/17 modified by haolong
	omap_mux_set_gpio(OMAP_MUX_MODE4, 15);	
//	if(omap_mux_init_gpio(15, OMAP_PIN_OUTPUT) < 0)
//	{
//			printk(KERN_ERR "Unable to mux GPIO15_IRQ\n");
//	}
//	if (gpio_request(15, "GPIO15_IRQ") < 0) {
//			printk(KERN_ERR "Unable to get IRQ GPIO\n");
//	}
//	gpio_direction_output(15, 1);
//---------------------------
}