/* * Routine: get_board_revision * Description: Detect if we are running on a Beagle revision Ax/Bx, * C1/2/3, C4 or xM. 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 */ int get_board_revision(void) { int revision; if (!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); 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); } else { printf("Error: unable to acquire board revision GPIOs\n"); revision = -1; } return revision; }
/* * Routine: get_board_revision * Description: Returns the board revision */ int get_board_revision(void) { int revision; if (!omap_request_gpio(126) && !omap_request_gpio(127) && !omap_request_gpio(128) && !omap_request_gpio(129)) { omap_set_gpio_direction(126, 1); omap_set_gpio_direction(127, 1); omap_set_gpio_direction(128, 1); omap_set_gpio_direction(129, 1); revision = 0; if (omap_get_gpio_datain(126) == 0) revision += 1; if (omap_get_gpio_datain(127) == 0) revision += 2; if (omap_get_gpio_datain(128) == 0) revision += 4; if (omap_get_gpio_datain(129) == 0) revision += 8; omap_free_gpio(126); omap_free_gpio(127); omap_free_gpio(128); omap_free_gpio(129); } else { printf("Error: unable to acquire board revision GPIOs\n"); revision=-1; } return revision; }
/* * Routine: get_sdio2_config * Description: Return information about the wifi module connection * Returns 0 if the module connects though a level translator * Returns 1 if the module connects directly */ int get_sdio2_config(void) { int sdio_direct; if (!omap_request_gpio(130) && !omap_request_gpio(139)) { omap_set_gpio_direction(130, 0); omap_set_gpio_direction(139, 1); sdio_direct = 1; omap_set_gpio_dataout(130, 0); if (omap_get_gpio_datain(139) == 0) { omap_set_gpio_dataout(130, 1); if (omap_get_gpio_datain(139) == 1) sdio_direct = 0; } omap_free_gpio(130); omap_free_gpio(139); } else { printf("Error: unable to acquire sdio2 clk GPIOs\n"); sdio_direct=-1; } return sdio_direct; }
static void palmte_pin_handler(unsigned long data) { int power, headphones; power = !omap_get_gpio_datain(PALMTE_DC_GPIO); headphones = omap_get_gpio_datain(PALMTE_HEADPHONES_GPIO); if (power && !prev_power) printk(KERN_INFO "PM: cable connected\n"); else if (!power && prev_power) printk(KERN_INFO "PM: cable disconnected\n"); if (headphones && !prev_headphones) { /* Headphones connected, disable speaker */ omap_set_gpio_dataout(PALMTE_SPEAKER_GPIO, 0); printk(KERN_INFO "PM: speaker off\n"); } else if (!headphones && prev_headphones) { /* Headphones unplugged, re-enable speaker */ omap_set_gpio_dataout(PALMTE_SPEAKER_GPIO, 1); printk(KERN_INFO "PM: speaker on\n"); } prev_power = power; prev_headphones = headphones; mod_timer(&palmte_pin_timer, jiffies + msecs_to_jiffies(500)); }
/* * Enable or disable power to TUSB6010. When enabling, turn on 3.3 V and * 1.5 V voltage regulators of PM companion chip. Companion chip will then * provide then PGOOD signal to TUSB6010 which will release it from reset. */ static int tusb_set_power(int state) { int i, retval = 0; if (state) { omap_set_gpio_dataout(GPIO_TUSB_ENABLE, 1); msleep(1); /* Wait until TUSB6010 pulls INT pin down */ i = 100; while (i && omap_get_gpio_datain(GPIO_TUSB_INT)) { msleep(1); i--; } if (!i) { printk(KERN_ERR "tusb: powerup failed\n"); retval = -ENODEV; } } else { omap_set_gpio_dataout(GPIO_TUSB_ENABLE, 0); msleep(10); } return retval; }
/* * 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); }
static void palmte_get_power_status(struct apm_power_info *info, int *battery) { int charging, batt, hi, lo, mid; charging = !omap_get_gpio_datain(PALMTE_DC_GPIO); batt = battery[0]; if (charging) batt -= 60; hi = ARRAY_SIZE(palmte_battery_sample); lo = 0; info->battery_flag = 0; info->units = APM_UNITS_MINS; if (batt > palmte_battery_sample[lo]) { info->battery_life = 100; info->time = INTERVAL * ARRAY_SIZE(palmte_battery_sample); } else if (batt <= palmte_battery_sample[hi - 1]) { info->battery_life = 0; info->time = 0; } else { while (hi > lo + 1) { mid = (hi + lo) >> 1; if (batt <= palmte_battery_sample[mid]) lo = mid; else hi = mid; } mid = palmte_battery_sample[lo] - palmte_battery_sample[hi]; hi = palmte_battery_sample[lo] - batt; info->battery_life = 100 - (100 * lo + 100 * hi / mid) / ARRAY_SIZE(palmte_battery_sample); info->time = INTERVAL * (ARRAY_SIZE(palmte_battery_sample) - lo) - INTERVAL * hi / mid; } if (charging) { info->ac_line_status = APM_AC_ONLINE; info->battery_status = APM_BATTERY_STATUS_CHARGING; info->battery_flag |= APM_BATTERY_FLAG_CHARGING; } else { info->ac_line_status = APM_AC_OFFLINE; if (info->battery_life > BATTERY_HIGH_TRESHOLD) info->battery_status = APM_BATTERY_STATUS_HIGH; else if (info->battery_life > BATTERY_LOW_TRESHOLD) info->battery_status = APM_BATTERY_STATUS_LOW; else info->battery_status = APM_BATTERY_STATUS_CRITICAL; } if (info->battery_life > BATTERY_HIGH_TRESHOLD) info->battery_flag |= APM_BATTERY_FLAG_HIGH; else if (info->battery_life > BATTERY_LOW_TRESHOLD) info->battery_flag |= APM_BATTERY_FLAG_LOW; else info->battery_flag |= APM_BATTERY_FLAG_CRITICAL; }
static ssize_t show_nl5350_intr(struct device *dev, struct device_attribute *attr, char *buf) { struct nl5350_struct *nl5350 = dev->platform_data; struct archos_gps_conf *conf = &nl5350->gps_conf; return snprintf(buf, PAGE_SIZE, "%d\n", omap_get_gpio_datain(GPIO_PIN(conf->gps_int))); };
static void brf6150_disable_pm_tx(struct brf6150_info *info) { if (info->pm_enabled) { info->tx_pm_enabled = 0; omap_set_gpio_dataout(info->btinfo->bt_wakeup_gpio, 1); } if (omap_get_gpio_datain(info->btinfo->host_wakeup_gpio)) tasklet_schedule(&info->tx_task); }
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; }
static u8 _cbus_receive_bit(struct cbus_host *host) { u8 ret; omap_set_gpio_dataout(host->clk_gpio, 1); ret = omap_get_gpio_datain(host->dat_gpio); omap_set_gpio_dataout(host->clk_gpio, 0); 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; }
irqreturn_t microusbic_interrupt(int irq, void *dev) { #if 0 int *id = (int *)dev; kmsg("2 irq : %d, gpio %d level =======> %d\n", irq , irq_to_gpio(irq), omap_get_gpio_datain(irq_to_gpio(irq))); #endif schedule_work(&work_device_intr); return IRQ_HANDLED; }
static u8 get_row_gpio_val(struct omap_kp *omap_kp) { int row; u8 value = 0; for (row = 0; row < omap_kp->rows; row++) { if (omap_get_gpio_datain(row_gpios[row])) value |= (1 << row); } return value; }
static void __init palmte_gpio_setup(void) { /* Set TSC2102 PINTDAV pin as input */ 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); /* Monitor cable-connected signals */ if (omap_request_gpio(PALMTE_DC_GPIO) || omap_request_gpio(PALMTE_USB_OR_DC_GPIO) || omap_request_gpio(PALMTE_USBDETECT_GPIO)) { printk(KERN_ERR "Could not reserve cable signal GPIO!\n"); return; } omap_set_gpio_direction(PALMTE_DC_GPIO, 1); omap_set_gpio_direction(PALMTE_USB_OR_DC_GPIO, 1); omap_set_gpio_direction(PALMTE_USBDETECT_GPIO, 1); /* Set speaker-enable pin as output */ if (omap_request_gpio(PALMTE_SPEAKER_GPIO)) { printk(KERN_ERR "Could not reserve speaker GPIO!\n"); return; } omap_set_gpio_direction(PALMTE_SPEAKER_GPIO, 0); /* Monitor the headphones-connected signal */ if (omap_request_gpio(PALMTE_HEADPHONES_GPIO)) { printk(KERN_ERR "Could not reserve headphones signal GPIO!\n"); return; } omap_set_gpio_direction(PALMTE_HEADPHONES_GPIO, 1); prev_power = omap_get_gpio_datain(PALMTE_DC_GPIO); prev_headphones = !omap_get_gpio_datain(PALMTE_HEADPHONES_GPIO); setup_timer(&palmte_pin_timer, palmte_pin_handler, 0); palmte_pin_handler(0); }
static irqreturn_t palmz71_powercable(int irq, void *dev_id) { if (omap_get_gpio_datain(PALMZ71_USBDETECT_GPIO)) { printk(KERN_INFO "PM: Power cable connected\n"); set_irq_type(OMAP_GPIO_IRQ(PALMZ71_USBDETECT_GPIO), IRQ_TYPE_EDGE_FALLING); } else { printk(KERN_INFO "PM: Power cable disconnected\n"); set_irq_type(OMAP_GPIO_IRQ(PALMZ71_USBDETECT_GPIO), IRQ_TYPE_EDGE_RISING); } return IRQ_HANDLED; }
/* * audio_pwr_up / down should be called under audio_pwr_lock */ static void nokia770_audio_pwr_up(void) { clk_enable(dspxor_ck); /* Turn on codec */ aic23_power_up(); if (omap_get_gpio_datain(HEADPHONE_GPIO)) /* HP not connected, turn on amplifier */ omap_set_gpio_dataout(AMPLIFIER_CTRL_GPIO, 1); else /* HP connected, do not turn on amplifier */ printk("HP connected\n"); }
static void __init htcoxygen_usb_enable(void) { unsigned int tries = 20; printk("trying to enable USB.\n"); /* force USB_EN GPIO to 0 */ do { omap_set_gpio_direction(33, 0); /* output */ omap_set_gpio_dataout(33, 0); /* low */ --tries; } while(omap_get_gpio_datain(33) && tries); if (tries) { printk("unable to reset USB_EN GPIO after 20 tries.\n"); printk("I will try to continue anyway: USB may not be available.\n"); } printk("USB_EN to 0 after %i tries.\n", tries); omap_set_gpio_dataout(73, 0); omap_set_gpio_direction(HTCWIZARD_GPIO_DM, 1); /* input */ /* get uart control from GSM */ /* select GPIO35 for D_MCLK_OUT */ /* select GPIO36 for D_CRESET */ omap_writel(omap_readl(OMAP730_IO_CONF_3) & 0xffffffcc, OMAP730_IO_CONF_3); omap_writel(omap_readl(OMAP730_IO_CONF_3) | 0x000000cc, OMAP730_IO_CONF_3); omap_set_gpio_direction(HTCWIZARD_GPIO_DP, 1); /* input */ /* select D_DM, D_DP for D_DM and disable PE_DM control */ omap_writel(omap_readl(OMAP730_IO_CONF_2) & 0xff1fffff, OMAP730_IO_CONF_2); omap_writel(omap_readl(OMAP730_IO_CONF_2) | 0x00100000, OMAP730_IO_CONF_2); mdelay(100); /* select USB_VBUSI for D_VBUSI, enable PE_VIBUSI pull enable control */ omap_writel(omap_readl(OMAP730_IO_CONF_2) & 0xf1ffffff, OMAP730_IO_CONF_2); omap_writel(omap_readl(OMAP730_IO_CONF_2) | 0x01000000, OMAP730_IO_CONF_2); /* set USB_VBUS_CTRL */ omap_writel(omap_readl(OMAP730_MODE_1) | (1 << 25), OMAP730_MODE_1); }
static irqreturn_t brf6150_wakeup_interrupt(int irq, void *dev_inst) { struct brf6150_info *info = dev_inst; int should_wakeup; unsigned long flags; spin_lock_irqsave(&info->lock, flags); should_wakeup = omap_get_gpio_datain(info->btinfo->host_wakeup_gpio); NBT_DBG_POWER("gpio interrupt %d\n", should_wakeup); if (should_wakeup) { clk_enable(info->uart_ck); brf6150_set_auto_ctsrts(info, 1); brf6150_rx(info); tasklet_schedule(&info->tx_task); } else { brf6150_set_auto_ctsrts(info, 0); brf6150_set_rts(info, 0); clk_disable(info->uart_ck); } spin_unlock_irqrestore(&info->lock, flags); return IRQ_HANDLED; }
/* * Routine: zoom2_identify * Description: Detect which version of Zoom2 we are running on. */ void zoom2_identify(void) { /* * To check for production board vs beta board, * check if gpio 94 is clear. * * No way yet to check for alpha board identity. * Alpha boards were produced in very limited quantities * and they are not commonly used. They are mentioned here * only for completeness. */ if (!omap_request_gpio(94)) { unsigned int val; omap_set_gpio_direction(94, 1); val = omap_get_gpio_datain(94); omap_free_gpio(94); if (val) revision = ZOOM2_REVISION_BETA; else revision = ZOOM2_REVISION_PRODUCTION; } printf("Board revision "); switch (revision) { case ZOOM2_REVISION_PRODUCTION: printf("Production\n"); break; case ZOOM2_REVISION_BETA: printf("Beta\n"); break; default: printf("Unknown\n"); break; } }
static int ads7846_get_pendown_state(void) { return !omap_get_gpio_datain(ADS7846_PENDOWN_GPIO); }
static int nand_dev_ready(struct nand_platform_data *data) { return omap_get_gpio_datain(P2_NAND_RB_GPIO_PIN); }
static int mistral_get_pendown_state(void) { return !omap_get_gpio_datain(4); }
static int palmtt_get_pendown_state(void) { return !omap_get_gpio_datain(6); }
static ssize_t show_5vusb(struct device *dev, struct device_attribute *attr, char* buf) { int val_5vusb = omap_get_gpio_datain( GPIO_PIN( gpio_5Vusb ) ); return snprintf(buf, PAGE_SIZE, "%i\n", val_5vusb); }
static int osk_ts_penup(void) { return (omap_get_gpio_datain(4)); }
static int n800_get_keyb_irq_state(struct device *dev) { return !omap_get_gpio_datain(N800_KEYB_IRQ_GPIO); }
int status_get_buttons(void) { // convert button state into led state (for mirror) int status=0; if(GPIO_AUX >= 0) status |= ((omap_get_gpio_datain(GPIO_AUX) == GPIO_AUX_ACTIVE) << 0); if(GPIO_GPSEXT >= 0) status |= ((omap_get_gpio_datain(GPIO_GPSEXT)) << 1); if(GPIO_POWER >= 0) status |= ((!omap_get_gpio_datain(GPIO_POWER)) << 3); else { u8 val; i2c_set_bus_num(TWL4030_I2C_BUS); // read I2C1 twl4030_i2c_read_u8(TWL4030_CHIP_PM_MASTER, &val, TWL4030_PM_MASTER_STS_HW_CONDITIONS); // read state of power button (bit 0) from TPS65950 status |= (((val&0x01) != 0) << 3); } if(GPIO_PENIRQ >= 0) status |= ((!omap_get_gpio_datain(GPIO_PENIRQ)) << 4); if(GPIO_KEYIRQ >= 0) status |= ((omap_get_gpio_datain(GPIO_KEYIRQ)) << 5); return status; #if OLD #if defined(CONFIG_OMAP3_GTA04) u8 val; i2c_set_bus_num(TWL4030_I2C_BUS); // read I2C1 twl4030_i2c_read_u8(TWL4030_CHIP_PM_MASTER, &val, TWL4030_PM_MASTER_STS_HW_CONDITIONS); // read state of power button (bit 0) from TPS65950 return ((omap_get_gpio_datain(GPIO_AUX)) << 0) | ((omap_get_gpio_datain(GPIO_GPSEXT)) << 1) | (((val&0x01) != 0) << 3) | ((omap_get_gpio_datain(GPIO_PENIRQ)) << 4); #elif defined(CONFIG_GOLDELICO_EXPANDER_B2) return ((omap_get_gpio_datain(GPIO_AUX)) << 0) | ((0) << 1) | ((GPIO_POWER>=0?(!omap_get_gpio_datain(GPIO_POWER)):0) << 3) | ((omap_get_gpio_datain(GPIO_PENIRQ)) << 4); #else return ((!omap_get_gpio_datain(GPIO_AUX)) << 0) | ((omap_get_gpio_datain(GPIO_GPSEXT)) << 1) | ((GPIO_POWER>=0?(!omap_get_gpio_datain(GPIO_POWER)):0) << 3) | ((omap_get_gpio_datain(GPIO_PENIRQ)) << 4); #endif #endif }
static ssize_t show_usb2sata_satardy(struct device* dev, struct device_attribute *attr, char* buf) { int satardy = omap_get_gpio_datain(GPIO_PIN(gpio_sata_rdy)); return snprintf(buf, PAGE_SIZE, "%d\n", satardy); }
static int palmz71_get_pendown_state(void) { return !omap_get_gpio_datain(PALMZ71_PENIRQ_GPIO); }