/*
* 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);
}
