void blue_LED_off (void)
{
/* blue */
if (!omap_request_gpio(ZOOM2_LED_BLUE)) {
omap_set_gpio_direction(ZOOM2_LED_BLUE, 0);
omap_set_gpio_dataout(ZOOM2_LED_BLUE, 0);
}
/* blue 2 */
if (!omap_request_gpio(ZOOM2_LED_BLUE2)) {
omap_set_gpio_direction(ZOOM2_LED_BLUE2, 0);
omap_set_gpio_dataout(ZOOM2_LED_BLUE2, 0);
}
saved_state[STATUS_LED_BLUE] = STATUS_LED_OFF;
}
static int __init
omap_leds_init(void)
{
if (machine_is_omap_innovator())
leds_event = innovator_leds_event;
else if (machine_is_omap_h2()
|| machine_is_omap_h3()
|| machine_is_omap_perseus2())
leds_event = h2p2_dbg_leds_event;
else if (machine_is_omap_osk())
leds_event = osk_leds_event;
else
return -1;
if (machine_is_omap_h2()
|| machine_is_omap_h3()
#ifdef CONFIG_OMAP_OSK_MISTRAL
|| machine_is_omap_osk()
#endif
) {
/* LED1/LED2 pins can be used as GPIO (as done here), or by
* the LPG (works even in deep sleep!), to drive a bicolor
* LED on the H2 sample board, and another on the H2/P2
* "surfer" expansion board.
*
* The same pins drive a LED on the OSK Mistral board, but
* that's a different kind of LED (just one color at a time).
*/
omap_cfg_reg(P18_1610_GPIO3);
if (omap_request_gpio(3) == 0)
omap_set_gpio_direction(3, 0);
else
printk(KERN_WARNING "LED: can't get GPIO3/red?\n");
omap_cfg_reg(MPUIO4);
if (omap_request_gpio(OMAP_MPUIO(4)) == 0)
omap_set_gpio_direction(OMAP_MPUIO(4), 0);
else
printk(KERN_WARNING "LED: can't get MPUIO4/green?\n");
}
leds_event(led_start);
return 0;
}
static inline void __init sdp3430_init_smc91x(void)
{
int eth_cs;
unsigned long cs_mem_base;
int eth_gpio = 0;
eth_cs = SDP3430_SMC91X_CS;
if (gpmc_cs_request(eth_cs, SZ_16M, &cs_mem_base) < 0) {
printk(KERN_ERR "Failed to request GPMC mem for smc91x\n");
return;
}
sdp3430_smc91x_resources[0].start = cs_mem_base + 0x0;
sdp3430_smc91x_resources[0].end = cs_mem_base + 0xf;
udelay(100);
if (is_sil_rev_greater_than(OMAP3430_REV_ES1_0))
eth_gpio = OMAP34XX_ETHR_GPIO_IRQ_SDPV2;
else
eth_gpio = OMAP34XX_ETHR_GPIO_IRQ_SDPV1;
sdp3430_smc91x_resources[1].start = OMAP_GPIO_IRQ(eth_gpio);
if (omap_request_gpio(eth_gpio) < 0) {
printk(KERN_ERR "Failed to request GPIO%d for smc91x IRQ\n",
eth_gpio);
return;
}
omap_set_gpio_direction(eth_gpio, 1);
}
void __init n800_usb_init(void)
{
int ret = 0;
static char announce[] __initdata = KERN_INFO "TUSB 6010\n";
/* PM companion chip power control pin */
ret = omap_request_gpio(GPIO_TUSB_ENABLE);
if (ret != 0) {
printk(KERN_ERR "Could not get TUSB power GPIO%i\n",
GPIO_TUSB_ENABLE);
return;
}
omap_set_gpio_direction(GPIO_TUSB_ENABLE, 0);
tusb_set_power(0);
ret = tusb6010_setup_interface(&tusb_data, TUSB6010_REFCLK_19, 2,
TUSB_ASYNC_CS, TUSB_SYNC_CS,
GPIO_TUSB_INT, 0x3f);
if (ret != 0)
goto err;
printk(announce);
return;
err:
omap_free_gpio(GPIO_TUSB_ENABLE);
}
static void setup_net_chip(void)
{
struct ctrl *ctrl_base = (struct ctrl *)OMAP34XX_CTRL_BASE;
enable_gpmc_cs_config(gpmc_lan_config, &gpmc_cfg->cs[5], 0x2C000000,
GPMC_SIZE_16M);
/* Enable off mode for NWE in PADCONF_GPMC_NWE register */
writew(readw(&ctrl_base->gpmc_nwe) | 0x0E00, &ctrl_base->gpmc_nwe);
/* Enable off mode for NOE in PADCONF_GPMC_NADV_ALE register */
writew(readw(&ctrl_base->gpmc_noe) | 0x0E00, &ctrl_base->gpmc_noe);
/* Enable off mode for ALE in PADCONF_GPMC_NADV_ALE register */
writew(readw(&ctrl_base->gpmc_nadv_ale) | 0x0E00,
&ctrl_base->gpmc_nadv_ale);
/* Make GPIO 64 as output pin and send a magic pulse through it */
if (!omap_request_gpio(64)) {
omap_set_gpio_direction(64, 0);
omap_set_gpio_dataout(64, 1);
udelay(1);
omap_set_gpio_dataout(64, 0);
udelay(1);
omap_set_gpio_dataout(64, 1);
}
}
static void __init h2_init_smc91x(void)
{
if ((omap_request_gpio(0)) < 0) {
printk("Error requesting gpio 0 for smc91x irq\n");
return;
}
}
/*
* Routine: beagle_identify
* Description: Detect if we are running on a Beagle revision Ax/Bx,
* C1/2/3, C4 or D. This can be done by reading
* the level of GPIO173, GPIO172 and GPIO171. This should
* result in
* GPIO173, GPIO172, GPIO171: 1 1 1 => Ax/Bx
* GPIO173, GPIO172, GPIO171: 1 1 0 => C1/2/3
* GPIO173, GPIO172, GPIO171: 1 0 1 => C4
* GPIO173, GPIO172, GPIO171: 0 0 0 => XM
*/
void beagle_identify(void)
{
omap_request_gpio(171);
omap_request_gpio(172);
omap_request_gpio(173);
omap_set_gpio_direction(171, 1);
omap_set_gpio_direction(172, 1);
omap_set_gpio_direction(173, 1);
beagle_revision = omap_get_gpio_datain(173) << 2 |
omap_get_gpio_datain(172) << 1 |
omap_get_gpio_datain(171);
omap_free_gpio(171);
omap_free_gpio(172);
omap_free_gpio(173);
}
/**
* Reset the ethernet chip.
*/
static void reset_net_chip(void)
{
int ret;
int rst_gpio;
if (get_omap3_evm_rev() == OMAP3EVM_BOARD_GEN_1) {
rst_gpio = OMAP3EVM_GPIO_ETH_RST_GEN1;
} else {
rst_gpio = OMAP3EVM_GPIO_ETH_RST_GEN2;
}
ret = omap_request_gpio(rst_gpio);
if (ret < 0) {
printf("Unable to get GPIO %d\n", rst_gpio);
return ;
}
/* Configure as output */
omap_set_gpio_direction(rst_gpio, 0);
/* Send a pulse on the GPIO pin */
omap_set_gpio_dataout(rst_gpio, 1);
udelay(1);
omap_set_gpio_dataout(rst_gpio, 0);
udelay(1);
omap_set_gpio_dataout(rst_gpio, 1);
}
static int __init osk_ts_probe(struct omap_ts_t *ts)
{
#ifdef CONFIG_OMAP_OSK_MISTRAL
if (!machine_is_omap_osk())
return -ENODEV;
/* Configure GPIO4 (pin M17 ZDY) as /PENIRQ interrupt input */
omap_cfg_reg(P20_1610_GPIO4);
omap_request_gpio(4);
omap_set_gpio_direction(4, 1);
set_irq_type(OMAP_GPIO_IRQ(4), IRQT_FALLING);
ts->irq = PEN_IRQ;
/* Configure uWire interface. ADS7846 is on CS0 */
omap_uwire_configure_mode(ADS7846_UWIRE_CS, UWIRE_READ_RISING_EDGE |
UWIRE_WRITE_RISING_EDGE |
UWIRE_CS_ACTIVE_LOW |
UWIRE_FREQ_DIV_2);
/* FIXME verify there's really a Mistral board:
* see if the AD7846 chip responds.
*/
/* NOTE: no VREF; must ignore the temp, VBAT, and AUX sensors */
return 0;
#else
return -ENODEV;
#endif
}
static void __init osk_mistral_init(void)
{
/* FIXME here's where to feed in framebuffer, touchpad, and
* keyboard setup ... not in the drivers for those devices!
*
* NOTE: we could actually tell if there's a Mistral board
* attached, e.g. by trying to read something from the ads7846.
* But this is too early for that...
*/
/* the sideways button (SW1) is for use as a "wakeup" button */
omap_cfg_reg(N15_1610_MPUIO2);
if (omap_request_gpio(OMAP_MPUIO(2)) == 0) {
int ret = 0;
omap_set_gpio_direction(OMAP_MPUIO(2), 1);
set_irq_type(OMAP_GPIO_IRQ(OMAP_MPUIO(2)), IRQT_RISING);
#ifdef CONFIG_PM
/* share the IRQ in case someone wants to use the
* button for more than wakeup from system sleep.
*/
ret = request_irq(OMAP_GPIO_IRQ(OMAP_MPUIO(2)),
&osk_mistral_wake_interrupt,
SA_SHIRQ, "mistral_wakeup",
&osk_mistral_wake_interrupt);
if (ret != 0) {
omap_free_gpio(OMAP_MPUIO(2));
printk(KERN_ERR "OSK+Mistral: no wakeup irq, %d?\n",
ret);
} else
enable_irq_wake(OMAP_GPIO_IRQ(OMAP_MPUIO(2)));
#endif
} else
printk(KERN_ERR "OSK+Mistral: wakeup button is awol\n");
}
static void __init h2_init(void)
{
/* Here we assume the NOR boot config: NOR on CS3 (possibly swapped
* to address 0 by a dip switch), NAND on CS2B. The NAND driver will
* notice whether a NAND chip is enabled at probe time.
*
* FIXME revC boards (and H3) support NAND-boot, with a dip switch to
* put NOR on CS2B and NAND (which on H2 may be 16bit) on CS3. Try
* detecting that in code here, to avoid probing every possible flash
* configuration...
*/
h2_nor_resource.end = h2_nor_resource.start = omap_cs3_phys();
h2_nor_resource.end += SZ_32M - 1;
omap_cfg_reg(L3_1610_FLASH_CS2B_OE);
omap_cfg_reg(M8_1610_FLASH_CS2B_WE);
/* MMC: card detect and WP */
// omap_cfg_reg(U19_ARMIO1); /* CD */
omap_cfg_reg(BALLOUT_V8_ARMIO3); /* WP */
/* Irda */
#if defined(CONFIG_OMAP_IR) || defined(CONFIG_OMAP_IR_MODULE)
omap_writel(omap_readl(FUNC_MUX_CTRL_A) | 7, FUNC_MUX_CTRL_A);
if (!(omap_request_gpio(H2_IRDA_FIRSEL_GPIO_PIN))) {
omap_set_gpio_direction(H2_IRDA_FIRSEL_GPIO_PIN, 0);
h2_irda_data.transceiver_mode = h2_transceiver_mode;
}
#endif
platform_add_devices(h2_devices, ARRAY_SIZE(h2_devices));
omap_board_config = h2_config;
omap_board_config_size = ARRAY_SIZE(h2_config);
omap_serial_init();
}
static int __init tea5761_dev_init(void)
{
const struct omap_tea5761_config *info;
int enable_gpio = 0;
info = omap_get_config(OMAP_TAG_TEA5761, struct omap_tea5761_config);
if (info)
enable_gpio = info->enable_gpio;
if (enable_gpio) {
pr_debug("Enabling tea5761 at GPIO %d\n",
enable_gpio);
if (omap_request_gpio(enable_gpio) < 0) {
printk(KERN_ERR "Can't request GPIO %d\n",
enable_gpio);
return -ENODEV;
}
omap_set_gpio_direction(enable_gpio, 0);
udelay(50);
omap_set_gpio_dataout(enable_gpio, 1);
}
return 0;
}
static void __init palmte_misc_gpio_setup(void)
{
/* Set TSC2102 PINTDAV pin as input (used by TSC2102 driver) */
if (omap_request_gpio(PALMTE_PINTDAV_GPIO)) {
printk(KERN_ERR "Could not reserve PINTDAV GPIO!\n");
return;
}
omap_set_gpio_direction(PALMTE_PINTDAV_GPIO, 1);
/* Set USB-or-DC-IN pin as input (unused) */
if (omap_request_gpio(PALMTE_USB_OR_DC_GPIO)) {
printk(KERN_ERR "Could not reserve cable signal GPIO!\n");
return;
}
omap_set_gpio_direction(PALMTE_USB_OR_DC_GPIO, 1);
}
static inline void __init apollon_init_smc91x(void)
{
unsigned long base;
/* Make sure CS1 timings are correct */
GPMC_CONFIG1_1 = 0x00011203;
GPMC_CONFIG2_1 = 0x001f1f01;
GPMC_CONFIG3_1 = 0x00080803;
GPMC_CONFIG4_1 = 0x1c091c09;
GPMC_CONFIG5_1 = 0x041f1f1f;
GPMC_CONFIG6_1 = 0x000004c4;
if (gpmc_cs_request(APOLLON_ETH_CS, SZ_16M, &base) < 0) {
printk(KERN_ERR "Failed to request GPMC CS for smc91x\n");
return;
}
apollon_smc91x_resources[0].start = base + 0x300;
apollon_smc91x_resources[0].end = base + 0x30f;
udelay(100);
omap_cfg_reg(W4__24XX_GPIO74);
if (omap_request_gpio(APOLLON_ETHR_GPIO_IRQ) < 0) {
printk(KERN_ERR "Failed to request GPIO%d for smc91x IRQ\n",
APOLLON_ETHR_GPIO_IRQ);
gpmc_cs_free(APOLLON_ETH_CS);
return;
}
omap_set_gpio_direction(APOLLON_ETHR_GPIO_IRQ, 1);
}
/*
* Routine: setup_net_chip
* Description: Setting up the configuration GPMC registers specific to the
* Ethernet hardware.
*/
static void setup_net_chip(void)
{
struct ctrl *ctrl_base = (struct ctrl *)OMAP34XX_CTRL_BASE;
/* Configure GPMC registers */
writel(NET_LAN9221_GPMC_CONFIG1, &gpmc_cfg->cs[5].config1);
writel(NET_LAN9221_GPMC_CONFIG2, &gpmc_cfg->cs[5].config2);
writel(NET_LAN9221_GPMC_CONFIG3, &gpmc_cfg->cs[5].config3);
writel(NET_LAN9221_GPMC_CONFIG4, &gpmc_cfg->cs[5].config4);
writel(NET_LAN9221_GPMC_CONFIG5, &gpmc_cfg->cs[5].config5);
writel(NET_LAN9221_GPMC_CONFIG6, &gpmc_cfg->cs[5].config6);
writel(NET_LAN9221_GPMC_CONFIG7, &gpmc_cfg->cs[5].config7);
/* Enable off mode for NWE in PADCONF_GPMC_NWE register */
writew(readw(&ctrl_base ->gpmc_nwe) | 0x0E00, &ctrl_base->gpmc_nwe);
/* Enable off mode for NOE in PADCONF_GPMC_NADV_ALE register */
writew(readw(&ctrl_base->gpmc_noe) | 0x0E00, &ctrl_base->gpmc_noe);
/* Enable off mode for ALE in PADCONF_GPMC_NADV_ALE register */
writew(readw(&ctrl_base->gpmc_nadv_ale) | 0x0E00,
&ctrl_base->gpmc_nadv_ale);
/* Make GPIO 64 as output pin and send a magic pulse through it */
if (!omap_request_gpio(64)) {
omap_set_gpio_direction(64, 0);
omap_set_gpio_dataout(64, 1);
udelay(1);
omap_set_gpio_dataout(64, 0);
udelay(1);
omap_set_gpio_dataout(64, 1);
}
}
static void __init h3_init(void)
{
/* Here we assume the NOR boot config: NOR on CS3 (possibly swapped
* to address 0 by a dip switch), NAND on CS2B. The NAND driver will
* notice whether a NAND chip is enabled at probe time.
*
* H3 support NAND-boot, with a dip switch to put NOR on CS2B and NAND
* (which on H2 may be 16bit) on CS3. Try detecting that in code here,
* to avoid probing every possible flash configuration...
*/
nor_resource.end = nor_resource.start = omap_cs3_phys();
nor_resource.end += SZ_32M - 1;
nand_resource.end = nand_resource.start = OMAP_CS2B_PHYS;
nand_resource.end += SZ_4K - 1;
if (!(omap_request_gpio(H3_NAND_RB_GPIO_PIN)))
nand_data.dev_ready = nand_dev_ready;
/* GPIO10 Func_MUX_CTRL reg bit 29:27, Configure V2 to mode1 as GPIO */
/* GPIO10 pullup/down register, Enable pullup on GPIO10 */
omap_cfg_reg(V2_1710_GPIO10);
platform_add_devices(devices, ARRAY_SIZE(devices));
omap_board_config = h3_config;
omap_board_config_size = ARRAY_SIZE(h3_config);
omap_serial_init();
}
static void omap_configure_led_gpio(int gpio)
{
if (omap_request_gpio(gpio) < 0) {
printk(KERN_ERR "Failed to request GPIO%d for LEDs\n", gpio);
return;
}
omap_set_gpio_direction(gpio, 0); /* OUT */
}
static void __init h3_init_smc91x(void)
{
omap_cfg_reg(W15_1710_GPIO40);
if (omap_request_gpio(40) < 0) {
printk("Error requesting gpio 40 for smc91x irq\n");
return;
}
}
static int sdp2430_panel_init(struct lcd_panel *panel,
struct omapfb_device *fbdev)
{
if (machine_is_omap_3430sdp()) {
enable_gpio = SDP3430_LCD_PANEL_ENABLE_GPIO;
backlight_gpio = SDP3430_LCD_PANEL_BACKLIGHT_GPIO;
} else {
enable_gpio = SDP2430_LCD_PANEL_ENABLE_GPIO;
backlight_gpio = SDP2430_LCD_PANEL_BACKLIGHT_GPIO;
}
omap_request_gpio(enable_gpio); /* LCD panel */
omap_request_gpio(backlight_gpio); /* LCD backlight */
omap_set_gpio_direction(enable_gpio, 0); /* output */
omap_set_gpio_direction(backlight_gpio, 0); /* output */
return 0;
}
static void __init apollon_led_init(void)
{
/* LED0 - AA10 */
omap_cfg_reg(AA10_242X_GPIO13);
omap_request_gpio(LED0_GPIO13);
omap_set_gpio_direction(LED0_GPIO13, 0);
omap_set_gpio_dataout(LED0_GPIO13, 0);
/* LED1 - AA6 */
omap_cfg_reg(AA6_242X_GPIO14);
omap_request_gpio(LED1_GPIO14);
omap_set_gpio_direction(LED1_GPIO14, 0);
omap_set_gpio_dataout(LED1_GPIO14, 0);
/* LED2 - AA4 */
omap_cfg_reg(AA4_242X_GPIO15);
omap_request_gpio(LED2_GPIO15);
omap_set_gpio_direction(LED2_GPIO15, 0);
omap_set_gpio_dataout(LED2_GPIO15, 0);
}
static void __init apollon_usb_init(void)
{
/* USB device */
/* DEVICE_SUSPEND */
omap_cfg_reg(P21_242X_GPIO12);
omap_request_gpio(12);
omap_set_gpio_direction(12, 0); /* OUT */
omap_set_gpio_dataout(12, 0);
}
static void __init apollon_tsc_init(void)
{
/* TSC2101 */
omap_cfg_reg(N15_24XX_GPIO85);
omap_request_gpio(85);
omap_set_gpio_direction(85, 1);
omap_cfg_reg(W14_24XX_SYS_CLKOUT); /* mclk */
}
static void __init h3_init_smc91x(void)
{
omap_cfg_reg(W15_1710_GPIO40);
if (omap_request_gpio(40) < 0) {
printk("Error requesting gpio 40 for smc91x irq\n");
return;
}
omap_set_gpio_edge_ctrl(40, OMAP_GPIO_FALLING_EDGE);
}
void red_LED_off (void)
{
/* red */
if (!omap_request_gpio(ZOOM2_LED_RED)) {
omap_set_gpio_direction(ZOOM2_LED_RED, 0);
omap_set_gpio_dataout(ZOOM2_LED_RED, 0);
}
saved_state[STATUS_LED_RED] = STATUS_LED_OFF;
}
static inline void __init sdp2430_init_smc91x(void)
{
int eth_cs;
unsigned long cs_mem_base;
unsigned int rate;
struct clk *l3ck;
eth_cs = SDP2430_SMC91X_CS;
l3ck = clk_get(NULL, "core_l3_ck");
if (IS_ERR(l3ck))
rate = 100000000;
else
rate = clk_get_rate(l3ck);
/* Make sure CS1 timings are correct, for 2430 always muxed */
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG1, 0x00011200);
if (rate >= 160000000) {
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG2, 0x001f1f01);
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG3, 0x00080803);
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG4, 0x1c0b1c0a);
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG5, 0x041f1F1F);
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG6, 0x000004C4);
} else if (rate >= 130000000) {
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG2, 0x001f1f00);
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG3, 0x00080802);
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG4, 0x1C091C09);
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG5, 0x041f1F1F);
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG6, 0x000004C4);
} else { /* rate = 100000000 */
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG2, 0x001f1f00);
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG3, 0x00080802);
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG4, 0x1C091C09);
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG5, 0x031A1F1F);
gpmc_cs_write_reg(eth_cs, GPMC_CS_CONFIG6, 0x000003C2);
}
if (gpmc_cs_request(eth_cs, SZ_16M, &cs_mem_base) < 0) {
printk(KERN_ERR "Failed to request GPMC mem for smc91x\n");
return;
}
sdp2430_smc91x_resources[0].start = cs_mem_base + 0x300;
sdp2430_smc91x_resources[0].end = cs_mem_base + 0x30f;
udelay(100);
if (omap_request_gpio(OMAP24XX_ETHR_GPIO_IRQ) < 0) {
printk(KERN_ERR "Failed to request GPIO%d for smc91x IRQ\n",
OMAP24XX_ETHR_GPIO_IRQ);
gpmc_cs_free(eth_cs);
return;
}
omap_set_gpio_direction(OMAP24XX_ETHR_GPIO_IRQ, 1);
}
static void __init osk_init_cf(void)
{
omap_cfg_reg(M7_1610_GPIO62);
if ((omap_request_gpio(62)) < 0) {
printk("Error requesting gpio 62 for CF irq\n");
return;
}
/* the CF I/O IRQ is really active-low */
set_irq_type(OMAP_GPIO_IRQ(62), IRQT_FALLING);
}
static void __init osk_init_smc91x(void)
{
if ((omap_request_gpio(0)) < 0) {
printk("Error requesting gpio 0 for smc91x irq\n");
return;
}
/* Check EMIFS wait states to fix errors with SMC_GET_PKT_HDR */
EMIFS_CCS(1) |= 0x3;
}
int is_critical_temperature(void)
{
int ret = 0;
omap_request_gpio(37);
omap_set_gpio_direction(37, 1);
ret = omap_get_gpio_datain(37);
return ret;
}
int is_ignition_on(void)
{
int ret;
omap_request_gpio(102); //in 1
omap_set_gpio_direction(102, 1);
ret = omap_get_gpio_datain(102);
return ret;
}
static void tsc2301_dev_init(void)
{
int gpio = N800_KEYB_IRQ_GPIO;
if (omap_request_gpio(gpio) < 0) {
printk(KERN_ERR "can't get KBIRQ GPIO\n");
return;
}
omap_set_gpio_direction(gpio, 1);
tsc2301_config.keyb_int = OMAP_GPIO_IRQ(gpio);
}
