Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 2c041f4b9be5cecbd0a042ecd9122a9db6f50416

Authored by Richard Purdie 2006-01-07 19:12:26 +0800

Committed by Russell King 2006-01-07 19:12:26 +0800

Exists in master and in 7 other branches

[ARM] 3235/1: SharpSL PM: Fix a gcc4 build error

Patch from Richard Purdie

Fix a gcc4 build error (incomplete element type) in the pxa SharpSL
PM code.

Signed-off-by: Richard Purdie <rpurdie@rpsys.net>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>

Showing 4 changed files with 1 additions and 3 deletions Inline Diff

arch/arm/mach-pxa/corgi_pm.c
arch/arm/mach-pxa/sharpsl.h
arch/arm/mach-pxa/sharpsl_pm.c
arch/arm/mach-pxa/spitz_pm.c

arch/arm/mach-pxa/corgi_pm.c

Diff comments View file @ 2c041f4

 /*
  * Battery and Power Management code for the Sharp SL-C7xx
  *
  * Copyright (c) 2005 Richard Purdie
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  */
 #include <linux/module.h>
 #include <linux/stat.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
 #include <asm/apm.h>
 #include <asm/irq.h>
 #include <asm/mach-types.h>
 #include <asm/hardware.h>
 #include <asm/hardware/scoop.h>
-#include <asm/hardware/sharpsl_pm.h>
 #include <asm/arch/sharpsl.h>
 #include <asm/arch/corgi.h>
 #include <asm/arch/pxa-regs.h>
 #include "sharpsl.h"
 static void corgi_charger_init(void)
 {
 	pxa_gpio_mode(CORGI_GPIO_ADC_TEMP_ON | GPIO_OUT);
 	pxa_gpio_mode(CORGI_GPIO_CHRG_ON | GPIO_OUT);
 	pxa_gpio_mode(CORGI_GPIO_CHRG_UKN | GPIO_OUT);
 	pxa_gpio_mode(CORGI_GPIO_KEY_INT | GPIO_IN);
 	sharpsl_pm_pxa_init();
 }
 static void corgi_measure_temp(int on)
 {
 	if (on)
 		GPSR(CORGI_GPIO_ADC_TEMP_ON) = GPIO_bit(CORGI_GPIO_ADC_TEMP_ON);
 	else
 		GPCR(CORGI_GPIO_ADC_TEMP_ON) = GPIO_bit(CORGI_GPIO_ADC_TEMP_ON);
 }
 static void corgi_charge(int on)
 {
 	if (on) {
 		if (machine_is_corgi() && (sharpsl_pm.flags & SHARPSL_SUSPENDED)) {
 			GPCR(CORGI_GPIO_CHRG_ON) = GPIO_bit(CORGI_GPIO_CHRG_ON);
 			GPSR(CORGI_GPIO_CHRG_UKN) = GPIO_bit(CORGI_GPIO_CHRG_UKN);
 		} else {
 			GPSR(CORGI_GPIO_CHRG_ON) = GPIO_bit(CORGI_GPIO_CHRG_ON);
 			GPCR(CORGI_GPIO_CHRG_UKN) = GPIO_bit(CORGI_GPIO_CHRG_UKN);
 		}
 	} else {
 		GPCR(CORGI_GPIO_CHRG_ON) = GPIO_bit(CORGI_GPIO_CHRG_ON);
 		GPCR(CORGI_GPIO_CHRG_UKN) = GPIO_bit(CORGI_GPIO_CHRG_UKN);
 	}
 }
 static void corgi_discharge(int on)
 {
 	if (on)
 		GPSR(CORGI_GPIO_DISCHARGE_ON) = GPIO_bit(CORGI_GPIO_DISCHARGE_ON);
 	else
 		GPCR(CORGI_GPIO_DISCHARGE_ON) = GPIO_bit(CORGI_GPIO_DISCHARGE_ON);
 }
 static void corgi_presuspend(void)
 {
 	int i;
 	unsigned long wakeup_mask;
 	/* charging , so CHARGE_ON bit is HIGH during OFF. */
 	if (READ_GPIO_BIT(CORGI_GPIO_CHRG_ON))
 		PGSR1 |= GPIO_bit(CORGI_GPIO_CHRG_ON);
 	else
 		PGSR1 &= ~GPIO_bit(CORGI_GPIO_CHRG_ON);
 	if (READ_GPIO_BIT(CORGI_GPIO_LED_ORANGE))
 		PGSR0 |= GPIO_bit(CORGI_GPIO_LED_ORANGE);
 	else
 		PGSR0 &= ~GPIO_bit(CORGI_GPIO_LED_ORANGE);
 	if (READ_GPIO_BIT(CORGI_GPIO_CHRG_UKN))
 		PGSR1 |= GPIO_bit(CORGI_GPIO_CHRG_UKN);
 	else
 		PGSR1 &= ~GPIO_bit(CORGI_GPIO_CHRG_UKN);
 	/* Resume on keyboard power key */
 	PGSR2 = (PGSR2 & ~CORGI_GPIO_ALL_STROBE_BIT) | CORGI_GPIO_STROBE_BIT(0);
 	wakeup_mask = GPIO_bit(CORGI_GPIO_KEY_INT) | GPIO_bit(CORGI_GPIO_WAKEUP) | GPIO_bit(CORGI_GPIO_AC_IN) | GPIO_bit(CORGI_GPIO_CHRG_FULL);
 	if (!machine_is_corgi())
 		wakeup_mask |= GPIO_bit(CORGI_GPIO_MAIN_BAT_LOW);
 	PWER = wakeup_mask | PWER_RTC;
 	PRER = wakeup_mask;
 	PFER = wakeup_mask;
 	for (i = 0; i <=15; i++) {
 		if (PRER & PFER & GPIO_bit(i)) {
 			if (GPLR0 & GPIO_bit(i) )
 				PRER &= ~GPIO_bit(i);
 			else
 				PFER &= ~GPIO_bit(i);
 		}
 	}
 }
 static void corgi_postsuspend(void)
 {
 }
 /*
  * Check what brought us out of the suspend.
  * Return: 0 to sleep, otherwise wake
  */
 static int corgi_should_wakeup(unsigned int resume_on_alarm)
 {
 	int is_resume = 0;
 	dev_dbg(sharpsl_pm.dev, "GPLR0 = %x,%x\n", GPLR0, PEDR);
 	if ((PEDR & GPIO_bit(CORGI_GPIO_AC_IN))) {
 		if (sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_ACIN)) {
 			/* charge on */
 			dev_dbg(sharpsl_pm.dev, "ac insert\n");
 			sharpsl_pm.flags |= SHARPSL_DO_OFFLINE_CHRG;
 		} else {
 			/* charge off */
 			dev_dbg(sharpsl_pm.dev, "ac remove\n");
 			sharpsl_pm_led(SHARPSL_LED_OFF);
 			sharpsl_pm.machinfo->charge(0);
 			sharpsl_pm.charge_mode = CHRG_OFF;
 		}
 	}
 	if ((PEDR & GPIO_bit(CORGI_GPIO_CHRG_FULL)))
 		dev_dbg(sharpsl_pm.dev, "Charge full interrupt\n");
 	if (PEDR & GPIO_bit(CORGI_GPIO_KEY_INT))
 		is_resume |= GPIO_bit(CORGI_GPIO_KEY_INT);
 	if (PEDR & GPIO_bit(CORGI_GPIO_WAKEUP))
 		is_resume |= GPIO_bit(CORGI_GPIO_WAKEUP);
 	if (resume_on_alarm && (PEDR & PWER_RTC))
 		is_resume |= PWER_RTC;
 	dev_dbg(sharpsl_pm.dev, "is_resume: %x\n",is_resume);
 	return is_resume;
 }
 static unsigned long corgi_charger_wakeup(void)
 {
 	return ~GPLR0 & ( GPIO_bit(CORGI_GPIO_AC_IN) | GPIO_bit(CORGI_GPIO_KEY_INT) | GPIO_bit(CORGI_GPIO_WAKEUP) );
 }
 unsigned long corgipm_read_devdata(int type)
 {
 	switch(type) {
 	case SHARPSL_STATUS_ACIN:
 		return ((GPLR(CORGI_GPIO_AC_IN) & GPIO_bit(CORGI_GPIO_AC_IN)) != 0);
 	case SHARPSL_STATUS_LOCK:
 		return READ_GPIO_BIT(sharpsl_pm.machinfo->gpio_batlock);
 	case SHARPSL_STATUS_CHRGFULL:
 		return READ_GPIO_BIT(sharpsl_pm.machinfo->gpio_batfull);
 	case SHARPSL_STATUS_FATAL:
 		return READ_GPIO_BIT(sharpsl_pm.machinfo->gpio_fatal);
 	case SHARPSL_ACIN_VOLT:
 		return sharpsl_pm_pxa_read_max1111(MAX1111_ACIN_VOLT);
 	case SHARPSL_BATT_TEMP:
 		return sharpsl_pm_pxa_read_max1111(MAX1111_BATT_TEMP);
 	case SHARPSL_BATT_VOLT:
 	default:
 		return sharpsl_pm_pxa_read_max1111(MAX1111_BATT_VOLT);
 	}
 }
 static struct sharpsl_charger_machinfo corgi_pm_machinfo = {
 	.init            = corgi_charger_init,
 	.exit            = sharpsl_pm_pxa_remove,
 	.gpio_batlock    = CORGI_GPIO_BAT_COVER,
 	.gpio_acin       = CORGI_GPIO_AC_IN,
 	.gpio_batfull    = CORGI_GPIO_CHRG_FULL,
 	.discharge       = corgi_discharge,
 	.charge          = corgi_charge,
 	.measure_temp    = corgi_measure_temp,
 	.presuspend      = corgi_presuspend,
 	.postsuspend     = corgi_postsuspend,
 	.read_devdata    = corgipm_read_devdata,
 	.charger_wakeup  = corgi_charger_wakeup,
 	.should_wakeup   = corgi_should_wakeup,
 	.bat_levels      = 40,
 	.bat_levels_noac = spitz_battery_levels_noac,
 	.bat_levels_acin = spitz_battery_levels_acin,
 	.status_high_acin = 188,
 	.status_low_acin  = 178,
 	.status_high_noac = 185,
 	.status_low_noac  = 175,
 };
 static struct platform_device *corgipm_device;
 static int __devinit corgipm_init(void)
 {
 	int ret;
 	corgipm_device = platform_device_alloc("sharpsl-pm", -1);
 	if (!corgipm_device)
 		return -ENOMEM;
 	corgipm_device->dev.platform_data = &corgi_pm_machinfo;
 	ret = platform_device_add(corgipm_device);
 	if (ret)
 		platform_device_put(corgipm_device);
 	return ret;
 }
 static void corgipm_exit(void)
 {
 	platform_device_unregister(corgipm_device);
 }
 module_init(corgipm_init);
 module_exit(corgipm_exit);

arch/arm/mach-pxa/sharpsl.h

Diff comments View file @ 2c041f4

 /*
  * Copyright (c) 2004-2005 Richard Purdie
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  */
+#include <asm/hardware/sharpsl_pm.h>
 /*
  * SharpSL SSP Driver
  */
 struct corgissp_machinfo {
 	int port;
 	int cs_lcdcon;
 	int cs_ads7846;
 	int cs_max1111;
 	int clk_lcdcon;
 	int clk_ads7846;
 	int clk_max1111;
 };
 void corgi_ssp_set_machinfo(struct corgissp_machinfo *machinfo);
 /*
  * SharpSL Backlight
  */
 void corgi_bl_set_intensity(int intensity);
 void spitz_bl_set_intensity(int intensity);
 void akita_bl_set_intensity(int intensity);
 /*
  * SharpSL Touchscreen Driver
  */
 unsigned long corgi_get_hsync_len(void);
 unsigned long spitz_get_hsync_len(void);
 void corgi_put_hsync(void);
 void spitz_put_hsync(void);
 void corgi_wait_hsync(void);
 void spitz_wait_hsync(void);
 /*
  * SharpSL Battery/PM Driver
  */
 #define READ_GPIO_BIT(x)    (GPLR(x) & GPIO_bit(x))
 /* MAX1111 Channel Definitions */
 #define MAX1111_BATT_VOLT   4u
 #define MAX1111_BATT_TEMP   2u
 #define MAX1111_ACIN_VOLT   6u
 extern struct battery_thresh spitz_battery_levels_acin[];
 extern struct battery_thresh spitz_battery_levels_noac[];
 void sharpsl_pm_pxa_init(void);
 void sharpsl_pm_pxa_remove(void);
 int sharpsl_pm_pxa_read_max1111(int channel);

arch/arm/mach-pxa/sharpsl_pm.c

Diff comments View file @ 2c041f4

 /*
  * Battery and Power Management code for the Sharp SL-C7xx and SL-Cxx00
  * series of PDAs
  *
  * Copyright (c) 2004-2005 Richard Purdie
  *
  * Based on code written by Sharp for 2.4 kernels
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  */
 #undef DEBUG
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
 #include <asm/hardware.h>
 #include <asm/mach-types.h>
 #include <asm/irq.h>
 #include <asm/apm.h>
 #include <asm/arch/pm.h>
 #include <asm/arch/pxa-regs.h>
 #include <asm/arch/sharpsl.h>
-#include <asm/hardware/sharpsl_pm.h>
 #include "sharpsl.h"
 struct battery_thresh spitz_battery_levels_acin[] = {
 	{ 213, 100},
 	{ 212,  98},
 	{ 211,  95},
 	{ 210,  93},
 	{ 209,  90},
 	{ 208,  88},
 	{ 207,  85},
 	{ 206,  83},
 	{ 205,  80},
 	{ 204,  78},
 	{ 203,  75},
 	{ 202,  73},
 	{ 201,  70},
 	{ 200,  68},
 	{ 199,  65},
 	{ 198,  63},
 	{ 197,  60},
 	{ 196,  58},
 	{ 195,  55},
 	{ 194,  53},
 	{ 193,  50},
 	{ 192,  48},
 	{ 192,  45},
 	{ 191,  43},
 	{ 191,  40},
 	{ 190,  38},
 	{ 190,  35},
 	{ 189,  33},
 	{ 188,  30},
 	{ 187,  28},
 	{ 186,  25},
 	{ 185,  23},
 	{ 184,  20},
 	{ 183,  18},
 	{ 182,  15},
 	{ 181,  13},
 	{ 180,  10},
 	{ 179,   8},
 	{ 178,   5},
 	{   0,   0},
 };
 struct battery_thresh  spitz_battery_levels_noac[] = {
 	{ 213, 100},
 	{ 212,  98},
 	{ 211,  95},
 	{ 210,  93},
 	{ 209,  90},
 	{ 208,  88},
 	{ 207,  85},
 	{ 206,  83},
 	{ 205,  80},
 	{ 204,  78},
 	{ 203,  75},
 	{ 202,  73},
 	{ 201,  70},
 	{ 200,  68},
 	{ 199,  65},
 	{ 198,  63},
 	{ 197,  60},
 	{ 196,  58},
 	{ 195,  55},
 	{ 194,  53},
 	{ 193,  50},
 	{ 192,  48},
 	{ 191,  45},
 	{ 190,  43},
 	{ 189,  40},
 	{ 188,  38},
 	{ 187,  35},
 	{ 186,  33},
 	{ 185,  30},
 	{ 184,  28},
 	{ 183,  25},
 	{ 182,  23},
 	{ 181,  20},
 	{ 180,  18},
 	{ 179,  15},
 	{ 178,  13},
 	{ 177,  10},
 	{ 176,   8},
 	{ 175,   5},
 	{   0,   0},
 };
 /* MAX1111 Commands */
 #define MAXCTRL_PD0      1u << 0
 #define MAXCTRL_PD1      1u << 1
 #define MAXCTRL_SGL      1u << 2
 #define MAXCTRL_UNI      1u << 3
 #define MAXCTRL_SEL_SH   4
 #define MAXCTRL_STR      1u << 7
 /*
  * Read MAX1111 ADC
  */
 int sharpsl_pm_pxa_read_max1111(int channel)
 {
 	return corgi_ssp_max1111_get((channel << MAXCTRL_SEL_SH) | MAXCTRL_PD0 | MAXCTRL_PD1
 			| MAXCTRL_SGL | MAXCTRL_UNI | MAXCTRL_STR);
 }
 void sharpsl_pm_pxa_init(void)
 {
 	pxa_gpio_mode(sharpsl_pm.machinfo->gpio_acin | GPIO_IN);
 	pxa_gpio_mode(sharpsl_pm.machinfo->gpio_batfull | GPIO_IN);
 	pxa_gpio_mode(sharpsl_pm.machinfo->gpio_batlock | GPIO_IN);
 	/* Register interrupt handlers */
 	if (request_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_acin), sharpsl_ac_isr, SA_INTERRUPT, "AC Input Detect", sharpsl_ac_isr)) {
 		dev_err(sharpsl_pm.dev, "Could not get irq %d.\n", IRQ_GPIO(sharpsl_pm.machinfo->gpio_acin));
 	}
 	else set_irq_type(IRQ_GPIO(sharpsl_pm.machinfo->gpio_acin),IRQT_BOTHEDGE);
 	if (request_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_batlock), sharpsl_fatal_isr, SA_INTERRUPT, "Battery Cover", sharpsl_fatal_isr)) {
 		dev_err(sharpsl_pm.dev, "Could not get irq %d.\n", IRQ_GPIO(sharpsl_pm.machinfo->gpio_batlock));
 	}
 	else set_irq_type(IRQ_GPIO(sharpsl_pm.machinfo->gpio_batlock),IRQT_FALLING);
 	if (sharpsl_pm.machinfo->gpio_fatal) {
 		if (request_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_fatal), sharpsl_fatal_isr, SA_INTERRUPT, "Fatal Battery", sharpsl_fatal_isr)) {
 			dev_err(sharpsl_pm.dev, "Could not get irq %d.\n", IRQ_GPIO(sharpsl_pm.machinfo->gpio_fatal));
 		}
 		else set_irq_type(IRQ_GPIO(sharpsl_pm.machinfo->gpio_fatal),IRQT_FALLING);
 	}
 	if (!machine_is_corgi())
 	{
 		/* Register interrupt handler. */
 		if (request_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_batfull), sharpsl_chrg_full_isr, SA_INTERRUPT, "CO", sharpsl_chrg_full_isr)) {
 			dev_err(sharpsl_pm.dev, "Could not get irq %d.\n", IRQ_GPIO(sharpsl_pm.machinfo->gpio_batfull));
 		}
 		else set_irq_type(IRQ_GPIO(sharpsl_pm.machinfo->gpio_batfull),IRQT_RISING);
 	}
 }
 void sharpsl_pm_pxa_remove(void)
 {
 	free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_acin), sharpsl_ac_isr);
 	free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_batlock), sharpsl_fatal_isr);
 	if (sharpsl_pm.machinfo->gpio_fatal)
 		free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_fatal), sharpsl_fatal_isr);
 	if (!machine_is_corgi())
 		free_irq(IRQ_GPIO(sharpsl_pm.machinfo->gpio_batfull), sharpsl_chrg_full_isr);
 }

arch/arm/mach-pxa/spitz_pm.c

Diff comments View file @ 2c041f4

 /*
  * Battery and Power Management code for the Sharp SL-Cxx00
  *
  * Copyright (c) 2005 Richard Purdie
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  */
 #include <linux/module.h>
 #include <linux/stat.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
 #include <asm/apm.h>
 #include <asm/irq.h>
 #include <asm/mach-types.h>
 #include <asm/hardware.h>
 #include <asm/hardware/scoop.h>
-#include <asm/hardware/sharpsl_pm.h>
 #include <asm/arch/sharpsl.h>
 #include <asm/arch/spitz.h>
 #include <asm/arch/pxa-regs.h>
 #include "sharpsl.h"
 static int spitz_last_ac_status;
 static void spitz_charger_init(void)
 {
 	pxa_gpio_mode(SPITZ_GPIO_KEY_INT | GPIO_IN);
 	pxa_gpio_mode(SPITZ_GPIO_SYNC | GPIO_IN);
 	sharpsl_pm_pxa_init();
 }
 static void spitz_measure_temp(int on)
 {
 	if (on)
 		set_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_ADC_TEMP_ON);
 	else
 		reset_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_ADC_TEMP_ON);
 }
 static void spitz_charge(int on)
 {
 	if (on) {
 		if (sharpsl_pm.flags & SHARPSL_SUSPENDED) {
 			set_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_JK_B);
 			reset_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_CHRG_ON);
 		} else {
 			reset_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_JK_B);
 			reset_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_CHRG_ON);
 		}
 	} else {
 		reset_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_JK_B);
 		set_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_CHRG_ON);
 	}
 }
 static void spitz_discharge(int on)
 {
 	if (on)
 		set_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_JK_A);
 	else
 		reset_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_JK_A);
 }
 /* HACK - For unknown reasons, accurate voltage readings are only made with a load
    on the power bus which the green led on spitz provides */
 static void spitz_discharge1(int on)
 {
 	if (on)
 		set_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_LED_GREEN);
 	else
 		reset_scoop_gpio(&spitzscoop_device.dev, SPITZ_SCP_LED_GREEN);
 }
 static void spitz_presuspend(void)
 {
 	spitz_last_ac_status = sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_ACIN);
 	/* GPIO Sleep Register */
 	PGSR0 = 0x00144018;
 	PGSR1 = 0x00EF0000;
 	if (machine_is_akita()) {
 		PGSR2 = 0x2121C000;
 		PGSR3 = 0x00600400;
 	} else {
 		PGSR2 = 0x0121C000;
 		PGSR3 = 0x00600000;
 	}
 	PGSR0 &= ~SPITZ_GPIO_G0_STROBE_BIT;
 	PGSR1 &= ~SPITZ_GPIO_G1_STROBE_BIT;
 	PGSR2 &= ~SPITZ_GPIO_G2_STROBE_BIT;
 	PGSR3 &= ~SPITZ_GPIO_G3_STROBE_BIT;
 	PGSR2 |= GPIO_bit(SPITZ_GPIO_KEY_STROBE0);
 	pxa_gpio_mode(GPIO18_RDY|GPIO_OUT | GPIO_DFLT_HIGH);
 	PRER = GPIO_bit(SPITZ_GPIO_KEY_INT);
 	PFER = GPIO_bit(SPITZ_GPIO_KEY_INT) | GPIO_bit(SPITZ_GPIO_RESET);
 	PWER = GPIO_bit(SPITZ_GPIO_KEY_INT) | GPIO_bit(SPITZ_GPIO_RESET) | PWER_RTC;
 	PKWR = GPIO_bit(SPITZ_GPIO_SYNC) | GPIO_bit(SPITZ_GPIO_KEY_INT) | GPIO_bit(SPITZ_GPIO_RESET);
 	PKSR = 0xffffffff; // clear
 	/* nRESET_OUT Disable */
 	PSLR |= PSLR_SL_ROD;
 	/* Clear reset status */
 	RCSR = RCSR_HWR | RCSR_WDR | RCSR_SMR | RCSR_GPR;
 	/* Stop 3.6MHz and drive HIGH to PCMCIA and CS */
 	PCFR = PCFR_GPR_EN | PCFR_OPDE;
 }
 static void spitz_postsuspend(void)
 {
 	pxa_gpio_mode(GPIO18_RDY_MD);
 	pxa_gpio_mode(10 | GPIO_IN);
 }
 static int spitz_should_wakeup(unsigned int resume_on_alarm)
 {
 	int is_resume = 0;
 	int acin = sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_ACIN);
 	if (spitz_last_ac_status != acin) {
 		if (acin) {
 			/* charge on */
 			sharpsl_pm.flags |= SHARPSL_DO_OFFLINE_CHRG;
 			dev_dbg(sharpsl_pm.dev, "AC Inserted\n");
 		} else {
 			/* charge off */
 			dev_dbg(sharpsl_pm.dev, "AC Removed\n");
 			sharpsl_pm_led(SHARPSL_LED_OFF);
 			sharpsl_pm.machinfo->charge(0);
 			sharpsl_pm.charge_mode = CHRG_OFF;
 		}
 		spitz_last_ac_status = acin;
 		/* Return to suspend as this must be what we were woken for */
 		return 0;
 	}
 	if (PEDR & GPIO_bit(SPITZ_GPIO_KEY_INT))
 		is_resume |= GPIO_bit(SPITZ_GPIO_KEY_INT);
 	if (PKSR & GPIO_bit(SPITZ_GPIO_SYNC))
 		is_resume |= GPIO_bit(SPITZ_GPIO_SYNC);
 	if (resume_on_alarm && (PEDR & PWER_RTC))
 		is_resume |= PWER_RTC;
 	dev_dbg(sharpsl_pm.dev, "is_resume: %x\n",is_resume);
 	return is_resume;
 }
 static unsigned long spitz_charger_wakeup(void)
 {
 	return (~GPLR0 & GPIO_bit(SPITZ_GPIO_KEY_INT)) | (GPLR0 & GPIO_bit(SPITZ_GPIO_SYNC));
 }
 unsigned long spitzpm_read_devdata(int type)
 {
 	switch(type) {
 	case SHARPSL_STATUS_ACIN:
 		return (((~GPLR(SPITZ_GPIO_AC_IN)) & GPIO_bit(SPITZ_GPIO_AC_IN)) != 0);
 	case SHARPSL_STATUS_LOCK:
 		return READ_GPIO_BIT(sharpsl_pm.machinfo->gpio_batlock);
 	case SHARPSL_STATUS_CHRGFULL:
 		return READ_GPIO_BIT(sharpsl_pm.machinfo->gpio_batfull);
 	case SHARPSL_STATUS_FATAL:
 		return READ_GPIO_BIT(sharpsl_pm.machinfo->gpio_fatal);
 	case SHARPSL_ACIN_VOLT:
 		return sharpsl_pm_pxa_read_max1111(MAX1111_ACIN_VOLT);
 	case SHARPSL_BATT_TEMP:
 		return sharpsl_pm_pxa_read_max1111(MAX1111_BATT_TEMP);
 	case SHARPSL_BATT_VOLT:
 	default:
 		return sharpsl_pm_pxa_read_max1111(MAX1111_BATT_VOLT);
 	}
 }
 struct sharpsl_charger_machinfo spitz_pm_machinfo = {
 	.init             = spitz_charger_init,
 	.exit             = sharpsl_pm_pxa_remove,
 	.gpio_batlock     = SPITZ_GPIO_BAT_COVER,
 	.gpio_acin        = SPITZ_GPIO_AC_IN,
 	.gpio_batfull     = SPITZ_GPIO_CHRG_FULL,
 	.gpio_fatal       = SPITZ_GPIO_FATAL_BAT,
 	.discharge        = spitz_discharge,
 	.discharge1       = spitz_discharge1,
 	.charge           = spitz_charge,
 	.measure_temp     = spitz_measure_temp,
 	.presuspend       = spitz_presuspend,
 	.postsuspend      = spitz_postsuspend,
 	.read_devdata     = spitzpm_read_devdata,
 	.charger_wakeup   = spitz_charger_wakeup,
 	.should_wakeup    = spitz_should_wakeup,
 	.bat_levels       = 40,
 	.bat_levels_noac  = spitz_battery_levels_noac,
 	.bat_levels_acin  = spitz_battery_levels_acin,
 	.status_high_acin = 188,
 	.status_low_acin  = 178,
 	.status_high_noac = 185,
 	.status_low_noac  = 175,
 };
 static struct platform_device *spitzpm_device;
 static int __devinit spitzpm_init(void)
 {
 	int ret;
 	spitzpm_device = platform_device_alloc("sharpsl-pm", -1);
 	if (!spitzpm_device)
 		return -ENOMEM;
 	spitzpm_device->dev.platform_data = &spitz_pm_machinfo;
 	ret = platform_device_add(spitzpm_device);
 	if (ret)
 		platform_device_put(spitzpm_device);
 	return ret;
 }
 static void spitzpm_exit(void)
 {
  	platform_device_unregister(spitzpm_device);
 }
 module_init(spitzpm_init);
 module_exit(spitzpm_exit);