2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* linux/arch/arm/mach-pxa/poodle.c
|
|
|
|
*
|
|
|
|
* Support for the SHARP Poodle Board.
|
|
|
|
*
|
|
|
|
* Based on:
|
|
|
|
* linux/arch/arm/mach-pxa/lubbock.c Author: Nicolas Pitre
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* Change Log
|
|
|
|
* 12-Dec-2002 Sharp Corporation for Poodle
|
|
|
|
* John Lenz <lenz@cs.wisc.edu> updates to 2.6
|
|
|
|
*/
|
|
|
|
#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/fb.h>
|
2006-06-19 12:57:12 -06:00
|
|
|
#include <linux/pm.h>
|
2006-06-19 12:58:51 -06:00
|
|
|
#include <linux/delay.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-08-05 09:14:15 -06:00
|
|
|
#include <mach/hardware.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <asm/mach-types.h>
|
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <asm/setup.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>
|
|
|
|
|
2008-08-05 09:14:15 -06:00
|
|
|
#include <mach/pxa-regs.h>
|
|
|
|
#include <mach/pxa2xx-regs.h>
|
|
|
|
#include <mach/pxa2xx-gpio.h>
|
|
|
|
#include <mach/mmc.h>
|
|
|
|
#include <mach/udc.h>
|
|
|
|
#include <mach/irda.h>
|
|
|
|
#include <mach/poodle.h>
|
|
|
|
#include <mach/pxafb.h>
|
|
|
|
#include <mach/sharpsl.h>
|
|
|
|
#include <mach/ssp.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <asm/hardware/scoop.h>
|
|
|
|
#include <asm/hardware/locomo.h>
|
|
|
|
#include <asm/mach/sharpsl_param.h>
|
|
|
|
|
|
|
|
#include "generic.h"
|
2007-05-15 08:39:36 -06:00
|
|
|
#include "devices.h"
|
2006-06-19 13:46:05 -06:00
|
|
|
#include "sharpsl.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static struct resource poodle_scoop_resources[] = {
|
|
|
|
[0] = {
|
|
|
|
.start = 0x10800000,
|
|
|
|
.end = 0x10800fff,
|
|
|
|
.flags = IORESOURCE_MEM,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct scoop_config poodle_scoop_setup = {
|
|
|
|
.io_dir = POODLE_SCOOP_IO_DIR,
|
|
|
|
.io_out = POODLE_SCOOP_IO_OUT,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct platform_device poodle_scoop_device = {
|
|
|
|
.name = "sharp-scoop",
|
|
|
|
.id = -1,
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &poodle_scoop_setup,
|
|
|
|
},
|
|
|
|
.num_resources = ARRAY_SIZE(poodle_scoop_resources),
|
|
|
|
.resource = poodle_scoop_resources,
|
|
|
|
};
|
|
|
|
|
2005-11-08 12:15:43 -07:00
|
|
|
static void poodle_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 poodle_pcmcia_scoop[] = {
|
|
|
|
{
|
|
|
|
.dev = &poodle_scoop_device.dev,
|
|
|
|
.irq = POODLE_IRQ_GPIO_CF_IRQ,
|
|
|
|
.cd_irq = POODLE_IRQ_GPIO_CF_CD,
|
|
|
|
.cd_irq_str = "PCMCIA0 CD",
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2005-11-08 12:15:43 -07:00
|
|
|
static struct scoop_pcmcia_config poodle_pcmcia_config = {
|
|
|
|
.devs = &poodle_pcmcia_scoop[0],
|
|
|
|
.num_devs = 1,
|
|
|
|
.pcmcia_init = poodle_pcmcia_init,
|
|
|
|
};
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(poodle_scoop_device);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* LoCoMo device */
|
|
|
|
static struct resource locomo_resources[] = {
|
|
|
|
[0] = {
|
|
|
|
.start = 0x10000000,
|
|
|
|
.end = 0x10001fff,
|
|
|
|
.flags = IORESOURCE_MEM,
|
|
|
|
},
|
|
|
|
[1] = {
|
|
|
|
.start = IRQ_GPIO(10),
|
|
|
|
.end = IRQ_GPIO(10),
|
|
|
|
.flags = IORESOURCE_IRQ,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2006-06-19 13:46:05 -06:00
|
|
|
struct platform_device poodle_locomo_device = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.name = "locomo",
|
|
|
|
.id = 0,
|
|
|
|
.num_resources = ARRAY_SIZE(locomo_resources),
|
|
|
|
.resource = locomo_resources,
|
|
|
|
};
|
|
|
|
|
2006-06-19 13:46:05 -06:00
|
|
|
EXPORT_SYMBOL(poodle_locomo_device);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Poodle SSP Device
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct platform_device poodle_ssp_device = {
|
|
|
|
.name = "corgi-ssp",
|
|
|
|
.id = -1,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct corgissp_machinfo poodle_ssp_machinfo = {
|
|
|
|
.port = 1,
|
|
|
|
.cs_lcdcon = -1,
|
|
|
|
.cs_ads7846 = -1,
|
|
|
|
.cs_max1111 = -1,
|
|
|
|
.clk_lcdcon = 2,
|
|
|
|
.clk_ads7846 = 36,
|
|
|
|
.clk_max1111 = 2,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Poodle Touch Screen Device
|
|
|
|
*/
|
|
|
|
static struct resource poodlets_resources[] = {
|
|
|
|
[0] = {
|
|
|
|
.start = POODLE_IRQ_GPIO_TP_INT,
|
|
|
|
.end = POODLE_IRQ_GPIO_TP_INT,
|
|
|
|
.flags = IORESOURCE_IRQ,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2008-01-30 18:41:16 -07:00
|
|
|
static unsigned long poodle_get_hsync_invperiod(void)
|
2006-06-19 13:46:05 -06:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void poodle_null_hsync(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct corgits_machinfo poodle_ts_machinfo = {
|
2008-01-30 18:41:16 -07:00
|
|
|
.get_hsync_invperiod = poodle_get_hsync_invperiod,
|
|
|
|
.put_hsync = poodle_null_hsync,
|
|
|
|
.wait_hsync = poodle_null_hsync,
|
2006-06-19 13:46:05 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_device poodle_ts_device = {
|
|
|
|
.name = "corgi-ts",
|
|
|
|
.dev = {
|
|
|
|
.platform_data = &poodle_ts_machinfo,
|
|
|
|
},
|
|
|
|
.id = -1,
|
|
|
|
.num_resources = ARRAY_SIZE(poodlets_resources),
|
|
|
|
.resource = poodlets_resources,
|
|
|
|
};
|
|
|
|
|
2005-09-15 07:53:22 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* MMC/SD Device
|
|
|
|
*
|
|
|
|
* The card detect interrupt isn't debounced so we delay it by 250ms
|
|
|
|
* to give the card a chance to fully insert/eject.
|
|
|
|
*/
|
|
|
|
static struct pxamci_platform_data poodle_mci_platform_data;
|
|
|
|
|
2006-10-09 05:19:47 -06:00
|
|
|
static int poodle_mci_init(struct device *dev, irq_handler_t poodle_detect_int, void *data)
|
2005-09-15 07:53:22 -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(POODLE_GPIO_nSD_DETECT | GPIO_IN);
|
2006-06-19 12:58:51 -06:00
|
|
|
pxa_gpio_mode(POODLE_GPIO_nSD_WP | GPIO_IN);
|
2005-09-15 07:53:22 -06:00
|
|
|
pxa_gpio_mode(POODLE_GPIO_SD_PWR | GPIO_OUT);
|
2006-06-19 12:58:51 -06:00
|
|
|
pxa_gpio_mode(POODLE_GPIO_SD_PWR1 | GPIO_OUT);
|
2005-09-15 07:53:22 -06:00
|
|
|
|
|
|
|
poodle_mci_platform_data.detect_delay = msecs_to_jiffies(250);
|
|
|
|
|
[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(POODLE_IRQ_GPIO_nSD_DETECT, poodle_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);
|
2008-01-23 07:05:58 -07:00
|
|
|
if (err)
|
2005-09-15 07:53:22 -06:00
|
|
|
printk(KERN_ERR "poodle_mci_init: MMC/SD: can't request MMC card detect IRQ\n");
|
|
|
|
|
2008-01-23 07:05:58 -07:00
|
|
|
return err;
|
2005-09-15 07:53:22 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void poodle_mci_setpower(struct device *dev, unsigned int vdd)
|
|
|
|
{
|
|
|
|
struct pxamci_platform_data* p_d = dev->platform_data;
|
|
|
|
|
2006-06-19 12:58:51 -06:00
|
|
|
if (( 1 << vdd) & p_d->ocr_mask) {
|
|
|
|
GPSR(POODLE_GPIO_SD_PWR) = GPIO_bit(POODLE_GPIO_SD_PWR);
|
|
|
|
mdelay(2);
|
|
|
|
GPSR(POODLE_GPIO_SD_PWR1) = GPIO_bit(POODLE_GPIO_SD_PWR1);
|
|
|
|
} else {
|
|
|
|
GPCR(POODLE_GPIO_SD_PWR1) = GPIO_bit(POODLE_GPIO_SD_PWR1);
|
|
|
|
GPCR(POODLE_GPIO_SD_PWR) = GPIO_bit(POODLE_GPIO_SD_PWR);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int poodle_mci_get_ro(struct device *dev)
|
|
|
|
{
|
|
|
|
return GPLR(POODLE_GPIO_nSD_WP) & GPIO_bit(POODLE_GPIO_nSD_WP);
|
2005-09-15 07:53:22 -06:00
|
|
|
}
|
|
|
|
|
2006-06-19 12:58:51 -06:00
|
|
|
|
2005-09-15 07:53:22 -06:00
|
|
|
static void poodle_mci_exit(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
free_irq(POODLE_IRQ_GPIO_nSD_DETECT, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct pxamci_platform_data poodle_mci_platform_data = {
|
|
|
|
.ocr_mask = MMC_VDD_32_33|MMC_VDD_33_34,
|
|
|
|
.init = poodle_mci_init,
|
2006-06-19 12:58:51 -06:00
|
|
|
.get_ro = poodle_mci_get_ro,
|
2005-09-15 07:53:22 -06:00
|
|
|
.setpower = poodle_mci_setpower,
|
|
|
|
.exit = poodle_mci_exit,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-10-30 07:38:52 -07:00
|
|
|
/*
|
|
|
|
* Irda
|
|
|
|
*/
|
|
|
|
static void poodle_irda_transceiver_mode(struct device *dev, int mode)
|
|
|
|
{
|
|
|
|
if (mode & IR_OFF) {
|
|
|
|
GPSR(POODLE_GPIO_IR_ON) = GPIO_bit(POODLE_GPIO_IR_ON);
|
|
|
|
} else {
|
|
|
|
GPCR(POODLE_GPIO_IR_ON) = GPIO_bit(POODLE_GPIO_IR_ON);
|
|
|
|
}
|
2008-07-02 06:54:46 -06:00
|
|
|
pxa2xx_transceiver_mode(dev, mode);
|
2005-10-30 07:38:52 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct pxaficp_platform_data poodle_ficp_platform_data = {
|
|
|
|
.transceiver_cap = IR_SIRMODE | IR_OFF,
|
|
|
|
.transceiver_mode = poodle_irda_transceiver_mode,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-09-15 07:53:22 -06:00
|
|
|
/*
|
|
|
|
* USB Device Controller
|
|
|
|
*/
|
|
|
|
static void poodle_udc_command(int cmd)
|
|
|
|
{
|
|
|
|
switch(cmd) {
|
|
|
|
case PXA2XX_UDC_CMD_CONNECT:
|
|
|
|
GPSR(POODLE_GPIO_USB_PULLUP) = GPIO_bit(POODLE_GPIO_USB_PULLUP);
|
|
|
|
break;
|
|
|
|
case PXA2XX_UDC_CMD_DISCONNECT:
|
|
|
|
GPCR(POODLE_GPIO_USB_PULLUP) = GPIO_bit(POODLE_GPIO_USB_PULLUP);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct pxa2xx_udc_mach_info udc_info __initdata = {
|
|
|
|
/* no connect GPIO; poodle can't tell connection status */
|
|
|
|
.udc_command = poodle_udc_command,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* PXAFB device */
|
2006-09-20 15:54:21 -06:00
|
|
|
static struct pxafb_mode_info poodle_fb_mode = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.pixclock = 144700,
|
|
|
|
.xres = 320,
|
|
|
|
.yres = 240,
|
|
|
|
.bpp = 16,
|
|
|
|
.hsync_len = 7,
|
|
|
|
.left_margin = 11,
|
|
|
|
.right_margin = 30,
|
|
|
|
.vsync_len = 2,
|
|
|
|
.upper_margin = 2,
|
|
|
|
.lower_margin = 0,
|
|
|
|
.sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
|
2006-09-20 15:54:21 -06:00
|
|
|
};
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-09-20 15:54:21 -06:00
|
|
|
static struct pxafb_mach_info poodle_fb_info = {
|
|
|
|
.modes = &poodle_fb_mode,
|
|
|
|
.num_modes = 1,
|
2005-04-16 16:20:36 -06:00
|
|
|
.lccr0 = LCCR0_Act | LCCR0_Sngl | LCCR0_Color,
|
|
|
|
.lccr3 = 0,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct platform_device *devices[] __initdata = {
|
2006-06-19 13:46:05 -06:00
|
|
|
&poodle_locomo_device,
|
2005-04-16 16:20:36 -06:00
|
|
|
&poodle_scoop_device,
|
2006-06-19 13:46:05 -06:00
|
|
|
&poodle_ssp_device,
|
|
|
|
&poodle_ts_device,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2006-06-19 12:57:12 -06:00
|
|
|
static void poodle_poweroff(void)
|
|
|
|
{
|
|
|
|
arm_machine_restart('h');
|
|
|
|
}
|
|
|
|
|
|
|
|
static void poodle_restart(char mode)
|
|
|
|
{
|
|
|
|
arm_machine_restart('h');
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void __init poodle_init(void)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
2006-06-19 12:57:12 -06:00
|
|
|
pm_power_off = poodle_poweroff;
|
|
|
|
arm_pm_restart = poodle_restart;
|
|
|
|
|
2005-09-15 07:53:22 -06:00
|
|
|
/* setup sleep mode values */
|
|
|
|
PWER = 0x00000002;
|
|
|
|
PFER = 0x00000000;
|
|
|
|
PRER = 0x00000002;
|
|
|
|
PGSR0 = 0x00008000;
|
|
|
|
PGSR1 = 0x003F0202;
|
|
|
|
PGSR2 = 0x0001C000;
|
|
|
|
PCFR |= PCFR_OPDE;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* cpu initialize */
|
|
|
|
/* Pgsr Register */
|
|
|
|
PGSR0 = 0x0146dd80;
|
|
|
|
PGSR1 = 0x03bf0890;
|
|
|
|
PGSR2 = 0x0001c000;
|
|
|
|
|
|
|
|
/* Alternate Register */
|
|
|
|
GAFR0_L = 0x01001000;
|
|
|
|
GAFR0_U = 0x591a8010;
|
|
|
|
GAFR1_L = 0x900a8451;
|
|
|
|
GAFR1_U = 0xaaa5aaaa;
|
|
|
|
GAFR2_L = 0x8aaaaaaa;
|
|
|
|
GAFR2_U = 0x00000002;
|
|
|
|
|
|
|
|
/* Direction Register */
|
|
|
|
GPDR0 = 0xd3f0904c;
|
|
|
|
GPDR1 = 0xfcffb7d3;
|
|
|
|
GPDR2 = 0x0001ffff;
|
|
|
|
|
|
|
|
/* Output Register */
|
|
|
|
GPCR0 = 0x00000000;
|
|
|
|
GPCR1 = 0x00000000;
|
|
|
|
GPCR2 = 0x00000000;
|
|
|
|
|
|
|
|
GPSR0 = 0x00400000;
|
|
|
|
GPSR1 = 0x00000000;
|
|
|
|
GPSR2 = 0x00000000;
|
|
|
|
|
2006-06-19 13:46:05 -06:00
|
|
|
set_pxa_fb_parent(&poodle_locomo_device.dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
set_pxa_fb_info(&poodle_fb_info);
|
2005-09-15 07:53:22 -06:00
|
|
|
pxa_gpio_mode(POODLE_GPIO_USB_PULLUP | GPIO_OUT);
|
2005-10-30 07:38:52 -07:00
|
|
|
pxa_gpio_mode(POODLE_GPIO_IR_ON | GPIO_OUT);
|
2005-09-15 07:53:22 -06:00
|
|
|
pxa_set_udc_info(&udc_info);
|
|
|
|
pxa_set_mci_info(&poodle_mci_platform_data);
|
2005-10-30 07:38:52 -07:00
|
|
|
pxa_set_ficp_info(&poodle_ficp_platform_data);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-11-08 12:15:43 -07:00
|
|
|
platform_scoop_config = &poodle_pcmcia_config;
|
2005-09-05 13:49:54 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
ret = platform_add_devices(devices, ARRAY_SIZE(devices));
|
|
|
|
if (ret) {
|
|
|
|
printk(KERN_WARNING "poodle: Unable to register LoCoMo device\n");
|
|
|
|
}
|
2006-06-19 13:46:05 -06:00
|
|
|
corgi_ssp_set_machinfo(&poodle_ssp_machinfo);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __init fixup_poodle(struct machine_desc *desc,
|
|
|
|
struct tag *tags, char **cmdline, struct meminfo *mi)
|
|
|
|
{
|
|
|
|
sharpsl_save_param();
|
2006-04-02 10:11:00 -06:00
|
|
|
mi->nr_banks=1;
|
|
|
|
mi->bank[0].start = 0xa0000000;
|
|
|
|
mi->bank[0].node = 0;
|
|
|
|
mi->bank[0].size = (32*1024*1024);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
MACHINE_START(POODLE, "SHARP Poodle")
|
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_poodle,
|
2005-09-15 07:53:22 -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
|
|
|
.timer = &pxa_timer,
|
|
|
|
.init_machine = poodle_init,
|
2005-04-16 16:20:36 -06:00
|
|
|
MACHINE_END
|