2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Support for Sharp SL-C7xx PDAs
|
|
|
|
* Models: SL-C700 (Corgi), SL-C750 (Shepherd), SL-C760 (Husky)
|
|
|
|
*
|
|
|
|
* Copyright (c) 2004-2005 Richard Purdie
|
|
|
|
*
|
|
|
|
* Based on Sharp's 2.4 kernel patches/lubbock.c
|
|
|
|
*
|
|
|
|
* 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/kernel.h>
|
|
|
|
#include <linux/init.h>
|
2005-10-29 12:07:23 -06:00
|
|
|
#include <linux/platform_device.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/major.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/mmc/host.h>
|
2006-06-19 12:57:12 -06:00
|
|
|
#include <linux/pm.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <asm/setup.h>
|
|
|
|
#include <asm/memory.h>
|
|
|
|
#include <asm/mach-types.h>
|
|
|
|
#include <asm/hardware.h>
|
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <asm/io.h>
|
2006-06-19 12:57:12 -06:00
|
|
|
#include <asm/system.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <asm/mach/arch.h>
|
|
|
|
#include <asm/mach/map.h>
|
|
|
|
#include <asm/mach/irq.h>
|
|
|
|
|
|
|
|
#include <asm/arch/pxa-regs.h>
|
2005-10-30 07:38:53 -07:00
|
|
|
#include <asm/arch/irda.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/arch/mmc.h>
|
|
|
|
#include <asm/arch/udc.h>
|
|
|
|
#include <asm/arch/corgi.h>
|
2005-10-10 03:17:45 -06:00
|
|
|
#include <asm/arch/sharpsl.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <asm/mach/sharpsl_param.h>
|
|
|
|
#include <asm/hardware/scoop.h>
|
|
|
|
|
|
|
|
#include "generic.h"
|
2005-09-13 02:25:30 -06:00
|
|
|
#include "sharpsl.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Corgi SCOOP Device
|
|
|
|
*/
|
|
|
|
static struct resource corgi_scoop_resources[] = {
|
|
|
|
[0] = {
|
|
|
|
.start = 0x10800000,
|
|
|
|
.end = 0x10800fff,
|
|
|
|
.flags = IORESOURCE_MEM,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct scoop_config corgi_scoop_setup = {
|
|
|
|
.io_dir = CORGI_SCOOP_IO_DIR,
|
|
|
|
.io_out = CORGI_SCOOP_IO_OUT,
|
|
|
|
};
|
|
|
|
|
2005-11-08 12:15:43 -07:00
|
|
|
struct platform_device corgiscoop_device = {
|
|
|
|
.name = "sharp-scoop",
|
|
|
|
.id = -1,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &corgi_scoop_setup,
|
|
|
|
},
|
|
|
|
.num_resources = ARRAY_SIZE(corgi_scoop_resources),
|
|
|
|
.resource = corgi_scoop_resources,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void corgi_pcmcia_init(void)
|
|
|
|
{
|
|
|
|
/* Setup default state of GPIO outputs
|
|
|
|
before we enable them as outputs. */
|
|
|
|
GPSR(GPIO48_nPOE) = GPIO_bit(GPIO48_nPOE) |
|
|
|
|
GPIO_bit(GPIO49_nPWE) | GPIO_bit(GPIO50_nPIOR) |
|
|
|
|
GPIO_bit(GPIO51_nPIOW) | GPIO_bit(GPIO52_nPCE_1) |
|
|
|
|
GPIO_bit(GPIO53_nPCE_2);
|
|
|
|
|
|
|
|
pxa_gpio_mode(GPIO48_nPOE_MD);
|
|
|
|
pxa_gpio_mode(GPIO49_nPWE_MD);
|
|
|
|
pxa_gpio_mode(GPIO50_nPIOR_MD);
|
|
|
|
pxa_gpio_mode(GPIO51_nPIOW_MD);
|
|
|
|
pxa_gpio_mode(GPIO55_nPREG_MD);
|
|
|
|
pxa_gpio_mode(GPIO56_nPWAIT_MD);
|
|
|
|
pxa_gpio_mode(GPIO57_nIOIS16_MD);
|
|
|
|
pxa_gpio_mode(GPIO52_nPCE_1_MD);
|
|
|
|
pxa_gpio_mode(GPIO53_nPCE_2_MD);
|
|
|
|
pxa_gpio_mode(GPIO54_pSKTSEL_MD);
|
|
|
|
}
|
|
|
|
|
2005-09-05 13:49:54 -06:00
|
|
|
static struct scoop_pcmcia_dev corgi_pcmcia_scoop[] = {
|
|
|
|
{
|
|
|
|
.dev = &corgiscoop_device.dev,
|
|
|
|
.irq = CORGI_IRQ_GPIO_CF_IRQ,
|
|
|
|
.cd_irq = CORGI_IRQ_GPIO_CF_CD,
|
|
|
|
.cd_irq_str = "PCMCIA0 CD",
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2005-11-08 12:15:43 -07:00
|
|
|
static struct scoop_pcmcia_config corgi_pcmcia_config = {
|
|
|
|
.devs = &corgi_pcmcia_scoop[0],
|
|
|
|
.num_devs = 1,
|
|
|
|
.pcmcia_init = corgi_pcmcia_init,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2005-11-08 12:15:43 -07:00
|
|
|
EXPORT_SYMBOL(corgiscoop_device);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Corgi SSP Device
|
|
|
|
*
|
|
|
|
* Set the parent as the scoop device because a lot of SSP devices
|
|
|
|
* also use scoop functions and this makes the power up/down order
|
|
|
|
* work correctly.
|
|
|
|
*/
|
2005-09-06 16:19:05 -06:00
|
|
|
struct platform_device corgissp_device = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.name = "corgi-ssp",
|
|
|
|
.dev = {
|
|
|
|
.parent = &corgiscoop_device.dev,
|
|
|
|
},
|
|
|
|
.id = -1,
|
|
|
|
};
|
|
|
|
|
2005-09-13 02:25:30 -06:00
|
|
|
struct corgissp_machinfo corgi_ssp_machinfo = {
|
|
|
|
.port = 1,
|
|
|
|
.cs_lcdcon = CORGI_GPIO_LCDCON_CS,
|
|
|
|
.cs_ads7846 = CORGI_GPIO_ADS7846_CS,
|
|
|
|
.cs_max1111 = CORGI_GPIO_MAX1111_CS,
|
|
|
|
.clk_lcdcon = 76,
|
|
|
|
.clk_ads7846 = 2,
|
|
|
|
.clk_max1111 = 8,
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Corgi Backlight Device
|
|
|
|
*/
|
2005-09-13 02:25:33 -06:00
|
|
|
static struct corgibl_machinfo corgi_bl_machinfo = {
|
|
|
|
.max_intensity = 0x2f,
|
2006-03-31 03:31:51 -07:00
|
|
|
.default_intensity = 0x1f,
|
|
|
|
.limit_mask = 0x0b,
|
2005-09-13 02:25:33 -06:00
|
|
|
.set_bl_intensity = corgi_bl_set_intensity,
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct platform_device corgibl_device = {
|
|
|
|
.name = "corgi-bl",
|
|
|
|
.dev = {
|
|
|
|
.parent = &corgifb_device.dev,
|
2005-09-13 02:25:33 -06:00
|
|
|
.platform_data = &corgi_bl_machinfo,
|
2005-04-16 16:20:36 -06:00
|
|
|
},
|
|
|
|
.id = -1,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-09-06 16:19:07 -06:00
|
|
|
/*
|
|
|
|
* Corgi Keyboard Device
|
|
|
|
*/
|
|
|
|
static struct platform_device corgikbd_device = {
|
|
|
|
.name = "corgi-keyboard",
|
|
|
|
.id = -1,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2006-03-31 03:31:09 -07:00
|
|
|
/*
|
|
|
|
* Corgi LEDs
|
|
|
|
*/
|
|
|
|
static struct platform_device corgiled_device = {
|
|
|
|
.name = "corgi-led",
|
|
|
|
.id = -1,
|
|
|
|
};
|
|
|
|
|
2005-09-06 16:19:07 -06:00
|
|
|
/*
|
|
|
|
* Corgi Touch Screen Device
|
|
|
|
*/
|
2005-09-13 02:25:33 -06:00
|
|
|
static struct resource corgits_resources[] = {
|
|
|
|
[0] = {
|
|
|
|
.start = CORGI_IRQ_GPIO_TP_INT,
|
|
|
|
.end = CORGI_IRQ_GPIO_TP_INT,
|
|
|
|
.flags = IORESOURCE_IRQ,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct corgits_machinfo corgi_ts_machinfo = {
|
|
|
|
.get_hsync_len = corgi_get_hsync_len,
|
|
|
|
.put_hsync = corgi_put_hsync,
|
|
|
|
.wait_hsync = corgi_wait_hsync,
|
|
|
|
};
|
|
|
|
|
2005-09-06 16:19:07 -06:00
|
|
|
static struct platform_device corgits_device = {
|
|
|
|
.name = "corgi-ts",
|
|
|
|
.dev = {
|
|
|
|
.parent = &corgissp_device.dev,
|
2005-09-13 02:25:33 -06:00
|
|
|
.platform_data = &corgi_ts_machinfo,
|
2005-09-06 16:19:07 -06:00
|
|
|
},
|
|
|
|
.id = -1,
|
2005-09-13 02:25:33 -06:00
|
|
|
.num_resources = ARRAY_SIZE(corgits_resources),
|
|
|
|
.resource = corgits_resources,
|
2005-09-06 16:19:07 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* MMC/SD Device
|
|
|
|
*
|
2005-09-09 11:54:03 -06:00
|
|
|
* The card detect interrupt isn't debounced so we delay it by 250ms
|
2005-04-16 16:20:36 -06:00
|
|
|
* to give the card a chance to fully insert/eject.
|
|
|
|
*/
|
2005-09-09 11:54:03 -06:00
|
|
|
static struct pxamci_platform_data corgi_mci_platform_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-10-09 05:19:47 -06:00
|
|
|
static int corgi_mci_init(struct device *dev, irq_handler_t corgi_detect_int, void *data)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/* setup GPIO for PXA25x MMC controller */
|
|
|
|
pxa_gpio_mode(GPIO6_MMCCLK_MD);
|
|
|
|
pxa_gpio_mode(GPIO8_MMCCS0_MD);
|
|
|
|
pxa_gpio_mode(CORGI_GPIO_nSD_DETECT | GPIO_IN);
|
|
|
|
pxa_gpio_mode(CORGI_GPIO_SD_PWR | GPIO_OUT);
|
|
|
|
|
2005-09-09 11:54:03 -06:00
|
|
|
corgi_mci_platform_data.detect_delay = msecs_to_jiffies(250);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[PATCH] IRQ type flags
Some ARM platforms have the ability to program the interrupt controller to
detect various interrupt edges and/or levels. For some platforms, this is
critical to setup correctly, particularly those which the setting is dependent
on the device.
Currently, ARM drivers do (eg) the following:
err = request_irq(irq, ...);
set_irq_type(irq, IRQT_RISING);
However, if the interrupt has previously been programmed to be level sensitive
(for whatever reason) then this will cause an interrupt storm.
Hence, if we combine set_irq_type() with request_irq(), we can then safely set
the type prior to unmasking the interrupt. The unfortunate problem is that in
order to support this, these flags need to be visible outside of the ARM
architecture - drivers such as smc91x need these flags and they're
cross-architecture.
Finally, the SA_TRIGGER_* flag passed to request_irq() should reflect the
property that the device would like. The IRQ controller code should do its
best to select the most appropriate supported mode.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-08 02:02:07 -07:00
|
|
|
err = request_irq(CORGI_IRQ_GPIO_nSD_DETECT, corgi_detect_int,
|
2006-07-02 18:20:05 -06:00
|
|
|
IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
|
[PATCH] IRQ type flags
Some ARM platforms have the ability to program the interrupt controller to
detect various interrupt edges and/or levels. For some platforms, this is
critical to setup correctly, particularly those which the setting is dependent
on the device.
Currently, ARM drivers do (eg) the following:
err = request_irq(irq, ...);
set_irq_type(irq, IRQT_RISING);
However, if the interrupt has previously been programmed to be level sensitive
(for whatever reason) then this will cause an interrupt storm.
Hence, if we combine set_irq_type() with request_irq(), we can then safely set
the type prior to unmasking the interrupt. The unfortunate problem is that in
order to support this, these flags need to be visible outside of the ARM
architecture - drivers such as smc91x need these flags and they're
cross-architecture.
Finally, the SA_TRIGGER_* flag passed to request_irq() should reflect the
property that the device would like. The IRQ controller code should do its
best to select the most appropriate supported mode.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-08 02:02:07 -07:00
|
|
|
"MMC card detect", data);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (err) {
|
|
|
|
printk(KERN_ERR "corgi_mci_init: MMC/SD: can't request MMC card detect IRQ\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void corgi_mci_setpower(struct device *dev, unsigned int vdd)
|
|
|
|
{
|
|
|
|
struct pxamci_platform_data* p_d = dev->platform_data;
|
|
|
|
|
2005-09-15 07:53:21 -06:00
|
|
|
if (( 1 << vdd) & p_d->ocr_mask)
|
2005-04-16 16:20:36 -06:00
|
|
|
GPSR1 = GPIO_bit(CORGI_GPIO_SD_PWR);
|
2005-09-15 07:53:21 -06:00
|
|
|
else
|
2005-04-16 16:20:36 -06:00
|
|
|
GPCR1 = GPIO_bit(CORGI_GPIO_SD_PWR);
|
|
|
|
}
|
|
|
|
|
2005-09-06 16:19:07 -06:00
|
|
|
static int corgi_mci_get_ro(struct device *dev)
|
|
|
|
{
|
|
|
|
return GPLR(CORGI_GPIO_nSD_WP) & GPIO_bit(CORGI_GPIO_nSD_WP);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void corgi_mci_exit(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
free_irq(CORGI_IRQ_GPIO_nSD_DETECT, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct pxamci_platform_data corgi_mci_platform_data = {
|
|
|
|
.ocr_mask = MMC_VDD_32_33|MMC_VDD_33_34,
|
|
|
|
.init = corgi_mci_init,
|
2005-09-06 16:19:07 -06:00
|
|
|
.get_ro = corgi_mci_get_ro,
|
2005-04-16 16:20:36 -06:00
|
|
|
.setpower = corgi_mci_setpower,
|
|
|
|
.exit = corgi_mci_exit,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-10-30 07:38:53 -07:00
|
|
|
/*
|
|
|
|
* Irda
|
|
|
|
*/
|
|
|
|
static void corgi_irda_transceiver_mode(struct device *dev, int mode)
|
|
|
|
{
|
|
|
|
if (mode & IR_OFF)
|
|
|
|
GPSR(CORGI_GPIO_IR_ON) = GPIO_bit(CORGI_GPIO_IR_ON);
|
|
|
|
else
|
|
|
|
GPCR(CORGI_GPIO_IR_ON) = GPIO_bit(CORGI_GPIO_IR_ON);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct pxaficp_platform_data corgi_ficp_platform_data = {
|
|
|
|
.transceiver_cap = IR_SIRMODE | IR_OFF,
|
|
|
|
.transceiver_mode = corgi_irda_transceiver_mode,
|
|
|
|
};
|
|
|
|
|
2005-09-06 16:19:07 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* USB Device Controller
|
|
|
|
*/
|
|
|
|
static struct pxa2xx_udc_mach_info udc_info __initdata = {
|
|
|
|
/* no connect GPIO; corgi can't tell connection status */
|
2006-06-29 13:25:39 -06:00
|
|
|
.gpio_pullup = CORGI_GPIO_USB_PULLUP,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static struct platform_device *devices[] __initdata = {
|
|
|
|
&corgiscoop_device,
|
|
|
|
&corgissp_device,
|
|
|
|
&corgifb_device,
|
2005-09-06 16:19:07 -06:00
|
|
|
&corgikbd_device,
|
2005-04-16 16:20:36 -06:00
|
|
|
&corgibl_device,
|
2005-09-06 16:19:07 -06:00
|
|
|
&corgits_device,
|
2006-03-31 03:31:09 -07:00
|
|
|
&corgiled_device,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2006-06-19 12:57:12 -06:00
|
|
|
static void corgi_poweroff(void)
|
|
|
|
{
|
|
|
|
RCSR = RCSR_HWR | RCSR_WDR | RCSR_SMR | RCSR_GPR;
|
|
|
|
|
|
|
|
if (!machine_is_corgi())
|
|
|
|
/* Green LED off tells the bootloader to halt */
|
|
|
|
reset_scoop_gpio(&corgiscoop_device.dev, CORGI_SCP_LED_GREEN);
|
|
|
|
arm_machine_restart('h');
|
|
|
|
}
|
|
|
|
|
|
|
|
static void corgi_restart(char mode)
|
|
|
|
{
|
|
|
|
RCSR = RCSR_HWR | RCSR_WDR | RCSR_SMR | RCSR_GPR;
|
|
|
|
|
|
|
|
if (!machine_is_corgi())
|
|
|
|
/* Green LED on tells the bootloader to reboot */
|
|
|
|
set_scoop_gpio(&corgiscoop_device.dev, CORGI_SCP_LED_GREEN);
|
|
|
|
arm_machine_restart('h');
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void __init corgi_init(void)
|
|
|
|
{
|
2006-06-19 12:57:12 -06:00
|
|
|
pm_power_off = corgi_poweroff;
|
|
|
|
arm_pm_restart = corgi_restart;
|
|
|
|
|
2005-09-15 07:53:21 -06:00
|
|
|
/* setup sleep mode values */
|
|
|
|
PWER = 0x00000002;
|
|
|
|
PFER = 0x00000000;
|
|
|
|
PRER = 0x00000002;
|
|
|
|
PGSR0 = 0x0158C000;
|
|
|
|
PGSR1 = 0x00FF0080;
|
|
|
|
PGSR2 = 0x0001C004;
|
|
|
|
/* Stop 3.6MHz and drive HIGH to PCMCIA and CS */
|
|
|
|
PCFR |= PCFR_OPDE;
|
|
|
|
|
2005-09-13 02:25:30 -06:00
|
|
|
corgi_ssp_set_machinfo(&corgi_ssp_machinfo);
|
|
|
|
|
2005-10-30 07:38:53 -07:00
|
|
|
pxa_gpio_mode(CORGI_GPIO_IR_ON | GPIO_OUT);
|
2005-09-13 02:25:33 -06:00
|
|
|
pxa_gpio_mode(CORGI_GPIO_HSYNC | GPIO_IN);
|
2005-10-30 07:38:53 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
pxa_set_udc_info(&udc_info);
|
|
|
|
pxa_set_mci_info(&corgi_mci_platform_data);
|
2005-10-30 07:38:53 -07:00
|
|
|
pxa_set_ficp_info(&corgi_ficp_platform_data);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-11-08 12:15:43 -07:00
|
|
|
platform_scoop_config = &corgi_pcmcia_config;
|
2005-09-05 13:49:54 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
platform_add_devices(devices, ARRAY_SIZE(devices));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init fixup_corgi(struct machine_desc *desc,
|
|
|
|
struct tag *tags, char **cmdline, struct meminfo *mi)
|
|
|
|
{
|
|
|
|
sharpsl_save_param();
|
|
|
|
mi->nr_banks=1;
|
|
|
|
mi->bank[0].start = 0xa0000000;
|
|
|
|
mi->bank[0].node = 0;
|
|
|
|
if (machine_is_corgi())
|
|
|
|
mi->bank[0].size = (32*1024*1024);
|
|
|
|
else
|
|
|
|
mi->bank[0].size = (64*1024*1024);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_MACH_CORGI
|
|
|
|
MACHINE_START(CORGI, "SHARP Corgi")
|
2005-07-03 10:38:58 -06:00
|
|
|
.phys_io = 0x40000000,
|
2005-07-04 03:44:34 -06:00
|
|
|
.io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc,
|
2005-07-03 10:38:58 -06:00
|
|
|
.fixup = fixup_corgi,
|
2005-09-15 07:53:21 -06:00
|
|
|
.map_io = pxa_map_io,
|
2007-06-21 21:14:09 -06:00
|
|
|
.init_irq = pxa25x_init_irq,
|
2005-07-03 10:38:58 -06:00
|
|
|
.init_machine = corgi_init,
|
|
|
|
.timer = &pxa_timer,
|
2005-04-16 16:20:36 -06:00
|
|
|
MACHINE_END
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_MACH_SHEPHERD
|
|
|
|
MACHINE_START(SHEPHERD, "SHARP Shepherd")
|
2005-07-03 10:38:58 -06:00
|
|
|
.phys_io = 0x40000000,
|
2005-07-04 03:44:34 -06:00
|
|
|
.io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc,
|
2005-07-03 10:38:58 -06:00
|
|
|
.fixup = fixup_corgi,
|
2005-09-15 07:53:21 -06:00
|
|
|
.map_io = pxa_map_io,
|
2007-06-21 21:14:09 -06:00
|
|
|
.init_irq = pxa25x_init_irq,
|
2005-07-03 10:38:58 -06:00
|
|
|
.init_machine = corgi_init,
|
|
|
|
.timer = &pxa_timer,
|
2005-04-16 16:20:36 -06:00
|
|
|
MACHINE_END
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_MACH_HUSKY
|
|
|
|
MACHINE_START(HUSKY, "SHARP Husky")
|
2005-07-03 10:38:58 -06:00
|
|
|
.phys_io = 0x40000000,
|
2005-07-04 03:44:34 -06:00
|
|
|
.io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc,
|
2005-07-03 10:38:58 -06:00
|
|
|
.fixup = fixup_corgi,
|
2005-09-15 07:53:21 -06:00
|
|
|
.map_io = pxa_map_io,
|
2007-06-21 21:14:09 -06:00
|
|
|
.init_irq = pxa25x_init_irq,
|
2005-07-03 10:38:58 -06:00
|
|
|
.init_machine = corgi_init,
|
|
|
|
.timer = &pxa_timer,
|
2005-04-16 16:20:36 -06:00
|
|
|
MACHINE_END
|
|
|
|
#endif
|
|
|
|
|