linux-kexecboot: update 2.6.26 patchset for poodle

1 files changed, 481 insertions, 0 deletions

diff --git a/recipes/kexecboot/linux-kexecboot-2.6.26/poodle_pm-r7.patch b/recipes/kexecboot/linux-kexecboot-2.6.26/poodle_pm-r7.patch
new file mode 100644
index 0000000000..75ad6213f4
--- /dev/null
+++ b/recipes/kexecboot/linux-kexecboot-2.6.26/poodle_pm-r7.patch
@@ -0,0 +1,481 @@
+ arch/arm/common/locomo.c          |    6
+ arch/arm/common/sharpsl_pm.c      |    9
+ arch/arm/mach-pxa/Kconfig         |    1
+ arch/arm/mach-pxa/Makefile        |    2
+ arch/arm/mach-pxa/poodle_pm.c     |  355 ++++++++++++++++++++++++++++++++++++++
+ include/asm-arm/hardware/locomo.h |    5
+ 6 files changed, 377 insertions(+), 1 deletion(-)
+
+Index: linux-2.6.26/arch/arm/common/sharpsl_pm.c
+===================================================================
+--- linux-2.6.26.orig/arch/arm/common/sharpsl_pm.c	2008-08-05 22:15:07.000000000 -0700
++++ linux-2.6.26/arch/arm/common/sharpsl_pm.c	2008-08-05 22:15:11.000000000 -0700
+@@ -458,6 +458,10 @@
+ {
+	int temp, i, buff[5];
+
++	/* Some devices don't support this */
++	if (!sharpsl_pm.machinfo->charge_acin_high)
++		return 0;
++
+	for (i=0; i<5; i++) {
+		buff[i] = sharpsl_pm.machinfo->read_devdata(SHARPSL_ACIN_VOLT);
+		mdelay(SHARPSL_CHECK_BATTERY_WAIT_TIME_ACIN);
+@@ -598,6 +602,9 @@
+
+	dev_dbg(sharpsl_pm.dev, "sharpsl_fatal_check entered\n");
+
++	if (machine_is_poodle())
++		return 0;
++
+	/* Check AC-Adapter */
+	acin = sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_ACIN);
+
+@@ -664,6 +671,7 @@
+		dev_dbg(sharpsl_pm.dev, "Offline Charger: Step 1\n");
+
+		/* AC Check */
++		if (!machine_is_poodle())
+		if ((sharpsl_ac_check() < 0) || (sharpsl_check_battery_temp() < 0))
+			return sharpsl_off_charge_error();
+
+@@ -686,6 +694,7 @@
+
+		dev_dbg(sharpsl_pm.dev, "Offline Charger: Step 2\n");
+
++		if (!machine_is_poodle())
+		if ((sharpsl_check_battery_temp() < 0) || (sharpsl_check_battery_voltage() < 0))
+			return sharpsl_off_charge_error();
+
+Index: linux-2.6.26/arch/arm/mach-pxa/Kconfig
+===================================================================
+--- linux-2.6.26.orig/arch/arm/mach-pxa/Kconfig	2008-08-05 22:15:05.000000000 -0700
++++ linux-2.6.26/arch/arm/mach-pxa/Kconfig	2008-08-05 22:16:25.000000000 -0700
+@@ -210,6 +210,7 @@
+	bool "Enable Sharp SL-5600 (Poodle) Support"
+	depends on PXA_SHARPSL_25x
+	select SHARP_LOCOMO
++	select SHARPSL_PM
+	select PXA_SSP
+
+ config MACH_CORGI
+Index: linux-2.6.26/arch/arm/mach-pxa/Makefile
+===================================================================
+--- linux-2.6.26.orig/arch/arm/mach-pxa/Makefile	2008-08-05 22:15:05.000000000 -0700
++++ linux-2.6.26/arch/arm/mach-pxa/Makefile	2008-08-05 22:16:25.000000000 -0700
+@@ -30,7 +30,7 @@
+ obj-$(CONFIG_PXA_SHARP_C7xx)	+= corgi.o corgi_ssp.o corgi_lcd.o sharpsl_pm.o corgi_pm.o
+ obj-$(CONFIG_PXA_SHARP_Cxx00)	+= spitz.o corgi_ssp.o corgi_lcd.o sharpsl_pm.o spitz_pm.o
+ obj-$(CONFIG_MACH_AKITA)	+= akita-ioexp.o
+-obj-$(CONFIG_MACH_POODLE)	+= poodle.o corgi_ssp.o
++obj-$(CONFIG_MACH_POODLE)	+= poodle.o corgi_ssp.o sharpsl_pm.o poodle_pm.o
+ obj-$(CONFIG_MACH_HX2750)	+= hx2750.o hx2750_test.o
+ obj-$(CONFIG_MACH_PCM027)	+= pcm027.o
+ obj-$(CONFIG_MACH_PCM990_BASEBOARD)	+= pcm990-baseboard.o
+Index: linux-2.6.26/arch/arm/mach-pxa/poodle_pm.c
+===================================================================
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.26/arch/arm/mach-pxa/poodle_pm.c	2008-08-05 22:21:31.000000000 -0700
+@@ -0,0 +1,356 @@
++/*
++ * Battery and Power Management code for the Sharp SL-5600
++ *
++ * Copyright (c) 2006 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 <linux/apm-emulation.h>
++#include <asm/irq.h>
++#include <asm/mach-types.h>
++#include <asm/hardware.h>
++#include <asm/hardware/scoop.h>
++#include <asm/hardware/locomo.h>
++
++#include <asm/arch/sharpsl.h>
++#include <asm/arch/poodle.h>
++#include <asm/arch/pxa-regs.h>
++#include <asm/arch/pxa2xx-gpio.h>
++#include "sharpsl.h"
++
++#if 0
++#define SHARPSL_CHARGE_ON_VOLT         0x99  /* 2.9V */
++#define SHARPSL_CHARGE_ON_TEMP         0xe0  /* 2.9V */
++#define SHARPSL_CHARGE_ON_ACIN_HIGH    0x9b  /* 6V */
++#define SHARPSL_CHARGE_ON_ACIN_LOW     0x34  /* 2V */
++#define SHARPSL_FATAL_ACIN_VOLT        182   /* 3.45V */
++#define SHARPSL_FATAL_NOACIN_VOLT      170   /* 3.40V */
++#endif
++
++#define SHARPSL_CHARGE_ON_VOLT			1187	// 2.9V
++#define SHARPSL_CHARGE_ON_TEMP			2441
++#define SHARPSL_FATAL_NOACIN_VOLT	1454    // 3.55V
++#define SHARPSL_FATAL_ACIN_VOLT	1474    // 3.60V
++
++
++#if 0
++#define SHARPSL_POWER_MODE_CHECK		1475
++#define SHARPSL_POODLE_FATAL_VOLT		1433
++#define SHARPSL_POODLE_FATAL_NOACIN_FLON_VOLT	1454    // 3.55V
++#define SHARPSL_POODLE_FATAL_NOACIN_FLOFF_VOLT	1433    // 3.50V
++#define SHARPSL_POODLE_FATAL_ACIN_FLON_VOLT	1474    // 3.60V
++#define SHARPSL_POODLE_FATAL_ACIN_FLOFF_VOLT	1454    // 3.55V
++#define SHARPSL_CHECK_BATTERY_WAIT_TIME_TEMP	5	// 50msec
++#define SHARPSL_CHECK_BATTERY_WAIT_TIME_VOLT	1	// 10msec
++#define SHARPSL_WAIT_DISCHARGE_ON		5	// 50msec
++#endif
++
++
++struct battery_thresh poodle_battery_levels_fl[] = {
++    {1582, 100},
++    {1527,  75},
++    {1482,  50},
++    {1458,  25},
++    {1404,   5},
++    {   0,   0},
++};
++
++struct battery_thresh poodle_battery_levels_nofl[] = {
++    {1589, 100},
++    {1536,  75},
++    {1490,  50},
++    {1466,  25},
++    {1413,   5},
++    {   0,   0},
++};
++
++struct battery_thresh poodle_battery_levels_acin_fl[] = {
++    {1601, 100},
++    {1536,  75},
++    {1503,  50},
++    {1482,  25},
++    {   0,   5},
++    {   0,   0},
++};
++
++struct battery_thresh poodle_battery_levels_acin_nofl[] = {
++    {1609, 100},
++    {1548,  75},
++    {1527,  50},
++    {1495,  25},
++    {   0,   5},
++    {   0,   0},
++};
++
++static void poodle_charger_init(void)
++{
++	pxa_gpio_mode(POODLE_GPIO_ADC_TEMP_ON | GPIO_OUT);
++	pxa_gpio_mode(POODLE_GPIO_CHRG_ON | GPIO_OUT);
++	pxa_gpio_mode(POODLE_GPIO_BYPASS_ON | GPIO_OUT);
++	pxa_gpio_mode(POODLE_GPIO_ON_KEY | GPIO_IN);
++	sharpsl_pm_pxa_init();
++}
++
++static void poodle_measure_temp(int on)
++{
++	if (on)
++		GPSR(POODLE_GPIO_ADC_TEMP_ON) = GPIO_bit(POODLE_GPIO_ADC_TEMP_ON);
++	else
++		GPCR(POODLE_GPIO_ADC_TEMP_ON) = GPIO_bit(POODLE_GPIO_ADC_TEMP_ON);
++}
++
++extern struct locomo_dev *frontlight_dev;
++
++static void poodle_charge(int on)
++{
++	if (on) {
++		GPSR(POODLE_GPIO_CHRG_ON) = GPIO_bit(POODLE_GPIO_CHRG_ON);
++		locomo_gpio_write(&poodle_locomo_device.dev, POODLE_LOCOMO_GPIO_JK_B, 1);
++	} else {
++		GPCR(POODLE_GPIO_CHRG_ON) = GPIO_bit(POODLE_GPIO_CHRG_ON);
++		locomo_gpio_write(&poodle_locomo_device.dev, POODLE_LOCOMO_GPIO_JK_B, 0);
++	}
++}
++
++static void poodle_discharge(int on)
++{
++	if (on)
++		GPSR(POODLE_GPIO_DISCHARGE_ON) = GPIO_bit(POODLE_GPIO_DISCHARGE_ON);
++	else
++		GPCR(POODLE_GPIO_DISCHARGE_ON) = GPIO_bit(POODLE_GPIO_DISCHARGE_ON);
++}
++
++static void poodle_presuspend(void)
++{
++	int i;
++	unsigned long wakeup_mask;
++
++	/* charging , so CHARGE_ON bit is HIGH during OFF. */
++	if (READ_GPIO_BIT(POODLE_GPIO_CHRG_ON))
++		PGSR1 |= GPIO_bit(POODLE_GPIO_CHRG_ON);
++	else
++		PGSR1 &= ~GPIO_bit(POODLE_GPIO_CHRG_ON);
++
++//	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(POODLE_GPIO_ON_KEY) | GPIO_bit(POODLE_GPIO_WAKEUP);
++	wakeup_mask |= GPIO_bit(POODLE_GPIO_AC_IN) | GPIO_bit(POODLE_GPIO_CHRG_FULL);
++	wakeup_mask |= GPIO_bit(POODLE_GPIO_MAIN_BAT_LOW) | GPIO_bit(POODLE_GPIO_CF_CD);
++	wakeup_mask |= GPIO_bit(POODLE_GPIO_HP_IN) | GPIO_bit(POODLE_GPIO_GA_INT) | GPIO_bit(POODLE_GPIO_nSD_INT);
++
++
++//	if (!machine_is_corgi())
++//		GPDR0 &= ~(GPIO_bit(15) | GPIO_bit(8)); /* Float n_CS1 */
++
++	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 poodle_postsuspend(void)
++{
++//	if (!machine_is_corgi())
++//		GPDR0 |= GPIO_bit(15) | GPIO_bit(8); /* Un-Float n_CS1 */
++}
++
++/*
++ * Check what brought us out of the suspend.
++ * Return: 0 to sleep, otherwise wake
++ */
++static int poodle_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(POODLE_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(POODLE_GPIO_CHRG_FULL)))
++		dev_dbg(sharpsl_pm.dev, "Charge full interrupt\n");
++
++	if (PEDR & GPIO_bit(POODLE_GPIO_ON_KEY))
++		is_resume |= GPIO_bit(POODLE_GPIO_ON_KEY);
++
++	if (PEDR & GPIO_bit(POODLE_GPIO_WAKEUP))
++		is_resume |= GPIO_bit(POODLE_GPIO_WAKEUP);
++
++//	if ( (apm_wakeup_factor & GPIO_bit(GPIO_GA_INT)) && (LCM_KIC & 1) ) {
++//		LCM_KIC &= ~0x100;
++//		LCM_ICR &= ~0x100;
++//		is_resume |= GPIO_bit(GPIO_GA_INT);
++//	}
++
++	if (PEDR & GPIO_bit(POODLE_GPIO_CF_STSCHG))
++		is_resume |= GPIO_bit(POODLE_GPIO_CF_STSCHG);
++
++	if (PEDR & GPIO_bit(POODLE_GPIO_nSD_INT))
++		is_resume |= GPIO_bit(POODLE_GPIO_nSD_INT);
++
++	if (PEDR & GPIO_bit(POODLE_GPIO_HP_IN))
++		is_resume |= GPIO_bit(POODLE_GPIO_HP_IN);
++
++	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 poodle_charger_wakeup(void)
++{
++	return ~GPLR0 & ( GPIO_bit(POODLE_GPIO_AC_IN) | GPIO_bit(POODLE_GPIO_ON_KEY) | GPIO_bit(POODLE_GPIO_WAKEUP) );
++}
++
++#define MUX_CHL    6u
++#define BATT_CHL   2u
++
++/* ADS7846 Touch Screen Controller bit definitions */
++#define ADSCTRL_PD0		(1u << 0)	/* PD0 */
++#define ADSCTRL_PD1		(1u << 1)	/* PD1 */
++#define ADSCTRL_DFR		(1u << 2)	/* SER/DFR */
++#define ADSCTRL_MOD		(1u << 3)	/* Mode */
++#define ADSCTRL_ADR_SH	4	/* Address setting */
++#define ADSCTRL_STS		(1u << 7)	/* Start Bit */
++
++int poodle_pm_read_ads7846(int channel)
++{
++	int voltage;
++	int cmd = ADSCTRL_PD0 | ADSCTRL_PD1 | ADSCTRL_DFR |
++		(channel << ADSCTRL_ADR_SH) | ADSCTRL_STS;
++
++	corgi_ssp_ads7846_lock();
++
++	corgi_ssp_ads7846_put(cmd);
++	corgi_ssp_ads7846_get();
++
++	corgi_ssp_ads7846_put(cmd);
++	voltage = corgi_ssp_ads7846_get();
++
++	/* Power-Down Enable */
++	corgi_ssp_ads7846_put((1u << ADSCTRL_ADR_SH) | ADSCTRL_STS);
++	corgi_ssp_ads7846_get();
++
++	corgi_ssp_ads7846_unlock();
++
++	return voltage;
++}
++
++unsigned long poodlepm_read_devdata(int type)
++{
++	switch(type) {
++	case SHARPSL_STATUS_ACIN:
++		return ((GPLR(POODLE_GPIO_AC_IN) & GPIO_bit(POODLE_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 poodle_pm_read_ads7846(MAX1111_ACIN_VOLT);
++// FIXME
++	case SHARPSL_BATT_TEMP:
++		return poodle_pm_read_ads7846(MUX_CHL);
++	case SHARPSL_BATT_VOLT:
++	default:
++		return poodle_pm_read_ads7846(BATT_CHL);
++	}
++}
++
++static void poodle_limit_intensity(int limit)
++{
++}
++
++static struct sharpsl_charger_machinfo poodle_pm_machinfo = {
++	.init            = poodle_charger_init,
++	.exit            = sharpsl_pm_pxa_remove,
++	.gpio_batlock    = POODLE_GPIO_BAT_COVER,
++	.gpio_acin       = POODLE_GPIO_AC_IN,
++	.gpio_batfull    = POODLE_GPIO_CHRG_FULL,
++	.batfull_irq	  = 1,
++	.discharge       = poodle_discharge,
++	.charge          = poodle_charge,
++	.measure_temp    = poodle_measure_temp,
++	.presuspend      = poodle_presuspend,
++	.postsuspend     = poodle_postsuspend,
++	.read_devdata    = poodlepm_read_devdata,
++	.charger_wakeup  = poodle_charger_wakeup,
++	.should_wakeup   = poodle_should_wakeup,
++	.backlight_limit =  poodle_limit_intensity,
++	.charge_on_volt	  = SHARPSL_CHARGE_ON_VOLT,
++	.charge_on_temp	  = SHARPSL_CHARGE_ON_TEMP,
++	.fatal_acin_volt  = SHARPSL_FATAL_ACIN_VOLT,
++	.fatal_noacin_volt= SHARPSL_FATAL_NOACIN_VOLT,
++	.bat_levels       = 6,
++	.bat_levels_noac  = poodle_battery_levels_fl,
++	.bat_levels_acin  = poodle_battery_levels_nofl,
++	.status_high_acin = 1490,
++	.status_low_acin  = 1466,
++	.status_high_noac = 1482,
++	.status_low_noac  = 1458,
++};
++
++static struct platform_device *poodlepm_device;
++
++static int __devinit poodlepm_init(void)
++{
++	int ret;
++
++	poodlepm_device = platform_device_alloc("sharpsl-pm", -1);
++	if (!poodlepm_device)
++		return -ENOMEM;
++
++	poodlepm_device->dev.platform_data = &poodle_pm_machinfo;
++	ret = platform_device_add(poodlepm_device);
++
++	if (ret)
++		platform_device_put(poodlepm_device);
++
++	return ret;
++}
++
++static void poodlepm_exit(void)
++{
++	platform_device_unregister(poodlepm_device);
++}
++
++module_init(poodlepm_init);
++module_exit(poodlepm_exit);
+Index: linux-2.6.26/arch/arm/common/locomo.c
+===================================================================
+--- linux-2.6.26.orig/arch/arm/common/locomo.c	2008-07-13 14:51:29.000000000 -0700
++++ linux-2.6.26/arch/arm/common/locomo.c	2008-08-05 22:16:20.000000000 -0700
+@@ -600,6 +600,7 @@
+	spin_lock_irqsave(&lchip->lock, flags);
+
+	save->LCM_GPO     = locomo_readl(lchip->base + LOCOMO_GPO);	/* GPIO */
++	// FIXME - should save JK_B
+	locomo_writel(0x00, lchip->base + LOCOMO_GPO);
+	save->LCM_SPICT   = locomo_readl(lchip->base + LOCOMO_SPI + LOCOMO_SPICT);	/* SPI */
+	locomo_writel(0x40, lchip->base + LOCOMO_SPICT);
+@@ -1101,11 +1102,16 @@
+
+ static struct locomo *locomo_chip_driver(struct locomo_dev *ldev);
+
++struct locomo_dev *frontlight_dev;
++EXPORT_SYMBOL(frontlight_dev);
++
+ void locomo_frontlight_set(struct locomo_dev *dev, int duty, int vr, int bpwf)
+ {
+	unsigned long flags;
+	struct locomo *lchip = locomo_chip_driver(dev);
+
++	frontlight_dev = dev;
++
+	if (vr)
+		locomo_gpio_write(dev->dev.parent, LOCOMO_GPIO_FL_VR, 1);
+	else
+Index: linux-2.6.26/include/asm-arm/hardware/locomo.h
+===================================================================
+--- linux-2.6.26.orig/include/asm-arm/hardware/locomo.h	2008-07-13 14:51:29.000000000 -0700
++++ linux-2.6.26/include/asm-arm/hardware/locomo.h	2008-08-05 22:15:11.000000000 -0700
+@@ -100,6 +100,12 @@
+ #define LOCOMO_GPIO_CARD_DETECT LOCOMO_GPIO(13)
+ #define LOCOMO_GPIO_WRITE_PROT  LOCOMO_GPIO(14)
+ #define LOCOMO_GPIO_CARD_POWER  LOCOMO_GPIO(15)
++#define POODLE_LOCOMO_GPIO_AMP_ON      LOCOMO_GPIO(8)
++#define POODLE_LOCOMO_GPIO_MUTE_L      LOCOMO_GPIO(10)
++#define POODLE_LOCOMO_GPIO_MUTE_R      LOCOMO_GPIO(11)
++#define POODLE_LOCOMO_GPIO_232VCC_ON   LOCOMO_GPIO(12)
++#define POODLE_LOCOMO_GPIO_JK_B        LOCOMO_GPIO(13)
++
+
+ /* Start the definitions of the devices.  Each device has an initial
+  * base address and a series of offsets from that base address. */