![Laura Abbott](/assets/img/avatar_default.png)
memblock is now fully integrated into the kernel and is the prefered method for tracking memory. Rather than reinvent the wheel with meminfo, migrate to using memblock directly instead of meminfo as an intermediate. Acked-by: Jason Cooper <jason@lakedaemon.net> Acked-by: Catalin Marinas <catalin.marinas@arm.com> Acked-by: Santosh Shilimkar <santosh.shilimkar@ti.com> Acked-by: Kukjin Kim <kgene.kim@samsung.com> Tested-by: Marek Szyprowski <m.szyprowski@samsung.com> Tested-by: Leif Lindholm <leif.lindholm@linaro.org> Signed-off-by: Laura Abbott <lauraa@codeaurora.org> Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
765 lines
18 KiB
C
765 lines
18 KiB
C
/*
|
|
* linux/arch/arm/mach-sa1100/assabet.c
|
|
*
|
|
* Author: Nicolas Pitre
|
|
*
|
|
* This file contains all Assabet-specific tweaks.
|
|
*
|
|
* 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/init.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/platform_data/sa11x0-serial.h>
|
|
#include <linux/serial_core.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/mfd/ucb1x00.h>
|
|
#include <linux/mtd/mtd.h>
|
|
#include <linux/mtd/partitions.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/leds.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include <video/sa1100fb.h>
|
|
|
|
#include <mach/hardware.h>
|
|
#include <asm/mach-types.h>
|
|
#include <asm/setup.h>
|
|
#include <asm/page.h>
|
|
#include <asm/pgtable-hwdef.h>
|
|
#include <asm/pgtable.h>
|
|
#include <asm/tlbflush.h>
|
|
|
|
#include <asm/mach/arch.h>
|
|
#include <asm/mach/flash.h>
|
|
#include <asm/mach/irda.h>
|
|
#include <asm/mach/map.h>
|
|
#include <mach/assabet.h>
|
|
#include <linux/platform_data/mfd-mcp-sa11x0.h>
|
|
#include <mach/irqs.h>
|
|
|
|
#include "generic.h"
|
|
|
|
#define ASSABET_BCR_DB1110 \
|
|
(ASSABET_BCR_SPK_OFF | \
|
|
ASSABET_BCR_LED_GREEN | ASSABET_BCR_LED_RED | \
|
|
ASSABET_BCR_RS232EN | ASSABET_BCR_LCD_12RGB | \
|
|
ASSABET_BCR_IRDA_MD0)
|
|
|
|
#define ASSABET_BCR_DB1111 \
|
|
(ASSABET_BCR_SPK_OFF | \
|
|
ASSABET_BCR_LED_GREEN | ASSABET_BCR_LED_RED | \
|
|
ASSABET_BCR_RS232EN | ASSABET_BCR_LCD_12RGB | \
|
|
ASSABET_BCR_CF_BUS_OFF | ASSABET_BCR_STEREO_LB | \
|
|
ASSABET_BCR_IRDA_MD0 | ASSABET_BCR_CF_RST)
|
|
|
|
unsigned long SCR_value = ASSABET_SCR_INIT;
|
|
EXPORT_SYMBOL(SCR_value);
|
|
|
|
static unsigned long BCR_value = ASSABET_BCR_DB1110;
|
|
|
|
void ASSABET_BCR_frob(unsigned int mask, unsigned int val)
|
|
{
|
|
unsigned long flags;
|
|
|
|
local_irq_save(flags);
|
|
BCR_value = (BCR_value & ~mask) | val;
|
|
ASSABET_BCR = BCR_value;
|
|
local_irq_restore(flags);
|
|
}
|
|
|
|
EXPORT_SYMBOL(ASSABET_BCR_frob);
|
|
|
|
/*
|
|
* The codec reset goes to three devices, so we need to release
|
|
* the rest when any one of these requests it. However, that
|
|
* causes the ADV7171 to consume around 100mA - more than half
|
|
* the LCD-blanked power.
|
|
*
|
|
* With the ADV7171, LCD and backlight enabled, we go over
|
|
* budget on the MAX846 Li-Ion charger, and if no Li-Ion battery
|
|
* is connected, the Assabet crashes.
|
|
*/
|
|
#define RST_UCB1X00 (1 << 0)
|
|
#define RST_UDA1341 (1 << 1)
|
|
#define RST_ADV7171 (1 << 2)
|
|
|
|
#define SDA GPIO_GPIO(15)
|
|
#define SCK GPIO_GPIO(18)
|
|
#define MOD GPIO_GPIO(17)
|
|
|
|
static void adv7171_start(void)
|
|
{
|
|
GPSR = SCK;
|
|
udelay(1);
|
|
GPSR = SDA;
|
|
udelay(2);
|
|
GPCR = SDA;
|
|
}
|
|
|
|
static void adv7171_stop(void)
|
|
{
|
|
GPSR = SCK;
|
|
udelay(2);
|
|
GPSR = SDA;
|
|
udelay(1);
|
|
}
|
|
|
|
static void adv7171_send(unsigned byte)
|
|
{
|
|
unsigned i;
|
|
|
|
for (i = 0; i < 8; i++, byte <<= 1) {
|
|
GPCR = SCK;
|
|
udelay(1);
|
|
if (byte & 0x80)
|
|
GPSR = SDA;
|
|
else
|
|
GPCR = SDA;
|
|
udelay(1);
|
|
GPSR = SCK;
|
|
udelay(1);
|
|
}
|
|
GPCR = SCK;
|
|
udelay(1);
|
|
GPSR = SDA;
|
|
udelay(1);
|
|
GPDR &= ~SDA;
|
|
GPSR = SCK;
|
|
udelay(1);
|
|
if (GPLR & SDA)
|
|
printk(KERN_WARNING "No ACK from ADV7171\n");
|
|
udelay(1);
|
|
GPCR = SCK | SDA;
|
|
udelay(1);
|
|
GPDR |= SDA;
|
|
udelay(1);
|
|
}
|
|
|
|
static void adv7171_write(unsigned reg, unsigned val)
|
|
{
|
|
unsigned gpdr = GPDR;
|
|
unsigned gplr = GPLR;
|
|
|
|
ASSABET_BCR = BCR_value | ASSABET_BCR_AUDIO_ON;
|
|
udelay(100);
|
|
|
|
GPCR = SDA | SCK | MOD; /* clear L3 mode to ensure UDA1341 doesn't respond */
|
|
GPDR = (GPDR | SCK | MOD) & ~SDA;
|
|
udelay(10);
|
|
if (!(GPLR & SDA))
|
|
printk(KERN_WARNING "Something dragging SDA down?\n");
|
|
GPDR |= SDA;
|
|
|
|
adv7171_start();
|
|
adv7171_send(0x54);
|
|
adv7171_send(reg);
|
|
adv7171_send(val);
|
|
adv7171_stop();
|
|
|
|
/* Restore GPIO state for L3 bus */
|
|
GPSR = gplr & (SDA | SCK | MOD);
|
|
GPCR = (~gplr) & (SDA | SCK | MOD);
|
|
GPDR = gpdr;
|
|
}
|
|
|
|
static void adv7171_sleep(void)
|
|
{
|
|
/* Put the ADV7171 into sleep mode */
|
|
adv7171_write(0x04, 0x40);
|
|
}
|
|
|
|
static unsigned codec_nreset;
|
|
|
|
static void assabet_codec_reset(unsigned mask, int set)
|
|
{
|
|
unsigned long flags;
|
|
bool old;
|
|
|
|
local_irq_save(flags);
|
|
old = !codec_nreset;
|
|
if (set)
|
|
codec_nreset &= ~mask;
|
|
else
|
|
codec_nreset |= mask;
|
|
|
|
if (old != !codec_nreset) {
|
|
if (codec_nreset) {
|
|
ASSABET_BCR_set(ASSABET_BCR_NCODEC_RST);
|
|
adv7171_sleep();
|
|
} else {
|
|
ASSABET_BCR_clear(ASSABET_BCR_NCODEC_RST);
|
|
}
|
|
}
|
|
local_irq_restore(flags);
|
|
}
|
|
|
|
static void assabet_ucb1x00_reset(enum ucb1x00_reset state)
|
|
{
|
|
int set = state == UCB_RST_REMOVE || state == UCB_RST_SUSPEND ||
|
|
state == UCB_RST_PROBE_FAIL;
|
|
assabet_codec_reset(RST_UCB1X00, set);
|
|
}
|
|
|
|
void assabet_uda1341_reset(int set)
|
|
{
|
|
assabet_codec_reset(RST_UDA1341, set);
|
|
}
|
|
EXPORT_SYMBOL(assabet_uda1341_reset);
|
|
|
|
|
|
/*
|
|
* Assabet flash support code.
|
|
*/
|
|
|
|
#ifdef ASSABET_REV_4
|
|
/*
|
|
* Phase 4 Assabet has two 28F160B3 flash parts in bank 0:
|
|
*/
|
|
static struct mtd_partition assabet_partitions[] = {
|
|
{
|
|
.name = "bootloader",
|
|
.size = 0x00020000,
|
|
.offset = 0,
|
|
.mask_flags = MTD_WRITEABLE,
|
|
}, {
|
|
.name = "bootloader params",
|
|
.size = 0x00020000,
|
|
.offset = MTDPART_OFS_APPEND,
|
|
.mask_flags = MTD_WRITEABLE,
|
|
}, {
|
|
.name = "jffs",
|
|
.size = MTDPART_SIZ_FULL,
|
|
.offset = MTDPART_OFS_APPEND,
|
|
}
|
|
};
|
|
#else
|
|
/*
|
|
* Phase 5 Assabet has two 28F128J3A flash parts in bank 0:
|
|
*/
|
|
static struct mtd_partition assabet_partitions[] = {
|
|
{
|
|
.name = "bootloader",
|
|
.size = 0x00040000,
|
|
.offset = 0,
|
|
.mask_flags = MTD_WRITEABLE,
|
|
}, {
|
|
.name = "bootloader params",
|
|
.size = 0x00040000,
|
|
.offset = MTDPART_OFS_APPEND,
|
|
.mask_flags = MTD_WRITEABLE,
|
|
}, {
|
|
.name = "jffs",
|
|
.size = MTDPART_SIZ_FULL,
|
|
.offset = MTDPART_OFS_APPEND,
|
|
}
|
|
};
|
|
#endif
|
|
|
|
static struct flash_platform_data assabet_flash_data = {
|
|
.map_name = "cfi_probe",
|
|
.parts = assabet_partitions,
|
|
.nr_parts = ARRAY_SIZE(assabet_partitions),
|
|
};
|
|
|
|
static struct resource assabet_flash_resources[] = {
|
|
DEFINE_RES_MEM(SA1100_CS0_PHYS, SZ_32M),
|
|
DEFINE_RES_MEM(SA1100_CS1_PHYS, SZ_32M),
|
|
};
|
|
|
|
|
|
/*
|
|
* Assabet IrDA support code.
|
|
*/
|
|
|
|
static int assabet_irda_set_power(struct device *dev, unsigned int state)
|
|
{
|
|
static unsigned int bcr_state[4] = {
|
|
ASSABET_BCR_IRDA_MD0,
|
|
ASSABET_BCR_IRDA_MD1|ASSABET_BCR_IRDA_MD0,
|
|
ASSABET_BCR_IRDA_MD1,
|
|
0
|
|
};
|
|
|
|
if (state < 4)
|
|
ASSABET_BCR_frob(ASSABET_BCR_IRDA_MD1 | ASSABET_BCR_IRDA_MD0,
|
|
bcr_state[state]);
|
|
return 0;
|
|
}
|
|
|
|
static void assabet_irda_set_speed(struct device *dev, unsigned int speed)
|
|
{
|
|
if (speed < 4000000)
|
|
ASSABET_BCR_clear(ASSABET_BCR_IRDA_FSEL);
|
|
else
|
|
ASSABET_BCR_set(ASSABET_BCR_IRDA_FSEL);
|
|
}
|
|
|
|
static struct irda_platform_data assabet_irda_data = {
|
|
.set_power = assabet_irda_set_power,
|
|
.set_speed = assabet_irda_set_speed,
|
|
};
|
|
|
|
static struct ucb1x00_plat_data assabet_ucb1x00_data = {
|
|
.reset = assabet_ucb1x00_reset,
|
|
.gpio_base = -1,
|
|
.can_wakeup = 1,
|
|
};
|
|
|
|
static struct mcp_plat_data assabet_mcp_data = {
|
|
.mccr0 = MCCR0_ADM,
|
|
.sclk_rate = 11981000,
|
|
.codec_pdata = &assabet_ucb1x00_data,
|
|
};
|
|
|
|
static void assabet_lcd_set_visual(u32 visual)
|
|
{
|
|
u_int is_true_color = visual == FB_VISUAL_TRUECOLOR;
|
|
|
|
if (machine_is_assabet()) {
|
|
#if 1 // phase 4 or newer Assabet's
|
|
if (is_true_color)
|
|
ASSABET_BCR_set(ASSABET_BCR_LCD_12RGB);
|
|
else
|
|
ASSABET_BCR_clear(ASSABET_BCR_LCD_12RGB);
|
|
#else
|
|
// older Assabet's
|
|
if (is_true_color)
|
|
ASSABET_BCR_clear(ASSABET_BCR_LCD_12RGB);
|
|
else
|
|
ASSABET_BCR_set(ASSABET_BCR_LCD_12RGB);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
#ifndef ASSABET_PAL_VIDEO
|
|
static void assabet_lcd_backlight_power(int on)
|
|
{
|
|
if (on)
|
|
ASSABET_BCR_set(ASSABET_BCR_LIGHT_ON);
|
|
else
|
|
ASSABET_BCR_clear(ASSABET_BCR_LIGHT_ON);
|
|
}
|
|
|
|
/*
|
|
* Turn on/off the backlight. When turning the backlight on, we wait
|
|
* 500us after turning it on so we don't cause the supplies to droop
|
|
* when we enable the LCD controller (and cause a hard reset.)
|
|
*/
|
|
static void assabet_lcd_power(int on)
|
|
{
|
|
if (on) {
|
|
ASSABET_BCR_set(ASSABET_BCR_LCD_ON);
|
|
udelay(500);
|
|
} else
|
|
ASSABET_BCR_clear(ASSABET_BCR_LCD_ON);
|
|
}
|
|
|
|
/*
|
|
* The assabet uses a sharp LQ039Q2DS54 LCD module. It is actually
|
|
* takes an RGB666 signal, but we provide it with an RGB565 signal
|
|
* instead (def_rgb_16).
|
|
*/
|
|
static struct sa1100fb_mach_info lq039q2ds54_info = {
|
|
.pixclock = 171521, .bpp = 16,
|
|
.xres = 320, .yres = 240,
|
|
|
|
.hsync_len = 5, .vsync_len = 1,
|
|
.left_margin = 61, .upper_margin = 3,
|
|
.right_margin = 9, .lower_margin = 0,
|
|
|
|
.sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
|
|
|
|
.lccr0 = LCCR0_Color | LCCR0_Sngl | LCCR0_Act,
|
|
.lccr3 = LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(2),
|
|
|
|
.backlight_power = assabet_lcd_backlight_power,
|
|
.lcd_power = assabet_lcd_power,
|
|
.set_visual = assabet_lcd_set_visual,
|
|
};
|
|
#else
|
|
static void assabet_pal_backlight_power(int on)
|
|
{
|
|
ASSABET_BCR_clear(ASSABET_BCR_LIGHT_ON);
|
|
}
|
|
|
|
static void assabet_pal_power(int on)
|
|
{
|
|
ASSABET_BCR_clear(ASSABET_BCR_LCD_ON);
|
|
}
|
|
|
|
static struct sa1100fb_mach_info pal_info = {
|
|
.pixclock = 67797, .bpp = 16,
|
|
.xres = 640, .yres = 512,
|
|
|
|
.hsync_len = 64, .vsync_len = 6,
|
|
.left_margin = 125, .upper_margin = 70,
|
|
.right_margin = 115, .lower_margin = 36,
|
|
|
|
.lccr0 = LCCR0_Color | LCCR0_Sngl | LCCR0_Act,
|
|
.lccr3 = LCCR3_OutEnH | LCCR3_PixRsEdg | LCCR3_ACBsDiv(512),
|
|
|
|
.backlight_power = assabet_pal_backlight_power,
|
|
.lcd_power = assabet_pal_power,
|
|
.set_visual = assabet_lcd_set_visual,
|
|
};
|
|
#endif
|
|
|
|
#ifdef CONFIG_ASSABET_NEPONSET
|
|
static struct resource neponset_resources[] = {
|
|
DEFINE_RES_MEM(0x10000000, 0x08000000),
|
|
DEFINE_RES_MEM(0x18000000, 0x04000000),
|
|
DEFINE_RES_MEM(0x40000000, SZ_8K),
|
|
DEFINE_RES_IRQ(IRQ_GPIO25),
|
|
};
|
|
#endif
|
|
|
|
static void __init assabet_init(void)
|
|
{
|
|
/*
|
|
* Ensure that the power supply is in "high power" mode.
|
|
*/
|
|
GPSR = GPIO_GPIO16;
|
|
GPDR |= GPIO_GPIO16;
|
|
|
|
/*
|
|
* Ensure that these pins are set as outputs and are driving
|
|
* logic 0. This ensures that we won't inadvertently toggle
|
|
* the WS latch in the CPLD, and we don't float causing
|
|
* excessive power drain. --rmk
|
|
*/
|
|
GPCR = GPIO_SSP_TXD | GPIO_SSP_SCLK | GPIO_SSP_SFRM;
|
|
GPDR |= GPIO_SSP_TXD | GPIO_SSP_SCLK | GPIO_SSP_SFRM;
|
|
|
|
/*
|
|
* Also set GPIO27 as an output; this is used to clock UART3
|
|
* via the FPGA and as otherwise has no pullups or pulldowns,
|
|
* so stop it floating.
|
|
*/
|
|
GPCR = GPIO_GPIO27;
|
|
GPDR |= GPIO_GPIO27;
|
|
|
|
/*
|
|
* Set up registers for sleep mode.
|
|
*/
|
|
PWER = PWER_GPIO0;
|
|
PGSR = 0;
|
|
PCFR = 0;
|
|
PSDR = 0;
|
|
PPDR |= PPC_TXD3 | PPC_TXD1;
|
|
PPSR |= PPC_TXD3 | PPC_TXD1;
|
|
|
|
sa11x0_ppc_configure_mcp();
|
|
|
|
if (machine_has_neponset()) {
|
|
/*
|
|
* Angel sets this, but other bootloaders may not.
|
|
*
|
|
* This must precede any driver calls to BCR_set()
|
|
* or BCR_clear().
|
|
*/
|
|
ASSABET_BCR = BCR_value = ASSABET_BCR_DB1111;
|
|
|
|
#ifndef CONFIG_ASSABET_NEPONSET
|
|
printk( "Warning: Neponset detected but full support "
|
|
"hasn't been configured in the kernel\n" );
|
|
#else
|
|
platform_device_register_simple("neponset", 0,
|
|
neponset_resources, ARRAY_SIZE(neponset_resources));
|
|
#endif
|
|
}
|
|
|
|
#ifndef ASSABET_PAL_VIDEO
|
|
sa11x0_register_lcd(&lq039q2ds54_info);
|
|
#else
|
|
sa11x0_register_lcd(&pal_video);
|
|
#endif
|
|
sa11x0_register_mtd(&assabet_flash_data, assabet_flash_resources,
|
|
ARRAY_SIZE(assabet_flash_resources));
|
|
sa11x0_register_irda(&assabet_irda_data);
|
|
sa11x0_register_mcp(&assabet_mcp_data);
|
|
}
|
|
|
|
/*
|
|
* On Assabet, we must probe for the Neponset board _before_
|
|
* paging_init() has occurred to actually determine the amount
|
|
* of RAM available. To do so, we map the appropriate IO section
|
|
* in the page table here in order to access GPIO registers.
|
|
*/
|
|
static void __init map_sa1100_gpio_regs( void )
|
|
{
|
|
unsigned long phys = __PREG(GPLR) & PMD_MASK;
|
|
unsigned long virt = (unsigned long)io_p2v(phys);
|
|
int prot = PMD_TYPE_SECT | PMD_SECT_AP_WRITE | PMD_DOMAIN(DOMAIN_IO);
|
|
pmd_t *pmd;
|
|
|
|
pmd = pmd_offset(pud_offset(pgd_offset_k(virt), virt), virt);
|
|
*pmd = __pmd(phys | prot);
|
|
flush_pmd_entry(pmd);
|
|
}
|
|
|
|
/*
|
|
* Read System Configuration "Register"
|
|
* (taken from "Intel StrongARM SA-1110 Microprocessor Development Board
|
|
* User's Guide", section 4.4.1)
|
|
*
|
|
* This same scan is performed in arch/arm/boot/compressed/head-sa1100.S
|
|
* to set up the serial port for decompression status messages. We
|
|
* repeat it here because the kernel may not be loaded as a zImage, and
|
|
* also because it's a hassle to communicate the SCR value to the kernel
|
|
* from the decompressor.
|
|
*
|
|
* Note that IRQs are guaranteed to be disabled.
|
|
*/
|
|
static void __init get_assabet_scr(void)
|
|
{
|
|
unsigned long uninitialized_var(scr), i;
|
|
|
|
GPDR |= 0x3fc; /* Configure GPIO 9:2 as outputs */
|
|
GPSR = 0x3fc; /* Write 0xFF to GPIO 9:2 */
|
|
GPDR &= ~(0x3fc); /* Configure GPIO 9:2 as inputs */
|
|
for(i = 100; i--; ) /* Read GPIO 9:2 */
|
|
scr = GPLR;
|
|
GPDR |= 0x3fc; /* restore correct pin direction */
|
|
scr &= 0x3fc; /* save as system configuration byte. */
|
|
SCR_value = scr;
|
|
}
|
|
|
|
static void __init
|
|
fixup_assabet(struct tag *tags, char **cmdline)
|
|
{
|
|
/* This must be done before any call to machine_has_neponset() */
|
|
map_sa1100_gpio_regs();
|
|
get_assabet_scr();
|
|
|
|
if (machine_has_neponset())
|
|
printk("Neponset expansion board detected\n");
|
|
}
|
|
|
|
|
|
static void assabet_uart_pm(struct uart_port *port, u_int state, u_int oldstate)
|
|
{
|
|
if (port->mapbase == _Ser1UTCR0) {
|
|
if (state)
|
|
ASSABET_BCR_clear(ASSABET_BCR_RS232EN |
|
|
ASSABET_BCR_COM_RTS |
|
|
ASSABET_BCR_COM_DTR);
|
|
else
|
|
ASSABET_BCR_set(ASSABET_BCR_RS232EN |
|
|
ASSABET_BCR_COM_RTS |
|
|
ASSABET_BCR_COM_DTR);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Assabet uses COM_RTS and COM_DTR for both UART1 (com port)
|
|
* and UART3 (radio module). We only handle them for UART1 here.
|
|
*/
|
|
static void assabet_set_mctrl(struct uart_port *port, u_int mctrl)
|
|
{
|
|
if (port->mapbase == _Ser1UTCR0) {
|
|
u_int set = 0, clear = 0;
|
|
|
|
if (mctrl & TIOCM_RTS)
|
|
clear |= ASSABET_BCR_COM_RTS;
|
|
else
|
|
set |= ASSABET_BCR_COM_RTS;
|
|
|
|
if (mctrl & TIOCM_DTR)
|
|
clear |= ASSABET_BCR_COM_DTR;
|
|
else
|
|
set |= ASSABET_BCR_COM_DTR;
|
|
|
|
ASSABET_BCR_clear(clear);
|
|
ASSABET_BCR_set(set);
|
|
}
|
|
}
|
|
|
|
static u_int assabet_get_mctrl(struct uart_port *port)
|
|
{
|
|
u_int ret = 0;
|
|
u_int bsr = ASSABET_BSR;
|
|
|
|
/* need 2 reads to read current value */
|
|
bsr = ASSABET_BSR;
|
|
|
|
if (port->mapbase == _Ser1UTCR0) {
|
|
if (bsr & ASSABET_BSR_COM_DCD)
|
|
ret |= TIOCM_CD;
|
|
if (bsr & ASSABET_BSR_COM_CTS)
|
|
ret |= TIOCM_CTS;
|
|
if (bsr & ASSABET_BSR_COM_DSR)
|
|
ret |= TIOCM_DSR;
|
|
} else if (port->mapbase == _Ser3UTCR0) {
|
|
if (bsr & ASSABET_BSR_RAD_DCD)
|
|
ret |= TIOCM_CD;
|
|
if (bsr & ASSABET_BSR_RAD_CTS)
|
|
ret |= TIOCM_CTS;
|
|
if (bsr & ASSABET_BSR_RAD_DSR)
|
|
ret |= TIOCM_DSR;
|
|
if (bsr & ASSABET_BSR_RAD_RI)
|
|
ret |= TIOCM_RI;
|
|
} else {
|
|
ret = TIOCM_CD | TIOCM_CTS | TIOCM_DSR;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static struct sa1100_port_fns assabet_port_fns __initdata = {
|
|
.set_mctrl = assabet_set_mctrl,
|
|
.get_mctrl = assabet_get_mctrl,
|
|
.pm = assabet_uart_pm,
|
|
};
|
|
|
|
static struct map_desc assabet_io_desc[] __initdata = {
|
|
{ /* Board Control Register */
|
|
.virtual = 0xf1000000,
|
|
.pfn = __phys_to_pfn(0x12000000),
|
|
.length = 0x00100000,
|
|
.type = MT_DEVICE
|
|
}, { /* MQ200 */
|
|
.virtual = 0xf2800000,
|
|
.pfn = __phys_to_pfn(0x4b800000),
|
|
.length = 0x00800000,
|
|
.type = MT_DEVICE
|
|
}
|
|
};
|
|
|
|
static void __init assabet_map_io(void)
|
|
{
|
|
sa1100_map_io();
|
|
iotable_init(assabet_io_desc, ARRAY_SIZE(assabet_io_desc));
|
|
|
|
/*
|
|
* Set SUS bit in SDCR0 so serial port 1 functions.
|
|
* Its called GPCLKR0 in my SA1110 manual.
|
|
*/
|
|
Ser1SDCR0 |= SDCR0_SUS;
|
|
MSC1 = (MSC1 & ~0xffff) |
|
|
MSC_NonBrst | MSC_32BitStMem |
|
|
MSC_RdAcc(2) | MSC_WrAcc(2) | MSC_Rec(0);
|
|
|
|
if (!machine_has_neponset())
|
|
sa1100_register_uart_fns(&assabet_port_fns);
|
|
|
|
/*
|
|
* When Neponset is attached, the first UART should be
|
|
* UART3. That's what Angel is doing and many documents
|
|
* are stating this.
|
|
*
|
|
* We do the Neponset mapping even if Neponset support
|
|
* isn't compiled in so the user will still get something on
|
|
* the expected physical serial port.
|
|
*
|
|
* We no longer do this; not all boot loaders support it,
|
|
* and UART3 appears to be somewhat unreliable with blob.
|
|
*/
|
|
sa1100_register_uart(0, 1);
|
|
sa1100_register_uart(2, 3);
|
|
}
|
|
|
|
/* LEDs */
|
|
#if defined(CONFIG_NEW_LEDS) && defined(CONFIG_LEDS_CLASS)
|
|
struct assabet_led {
|
|
struct led_classdev cdev;
|
|
u32 mask;
|
|
};
|
|
|
|
/*
|
|
* The triggers lines up below will only be used if the
|
|
* LED triggers are compiled in.
|
|
*/
|
|
static const struct {
|
|
const char *name;
|
|
const char *trigger;
|
|
} assabet_leds[] = {
|
|
{ "assabet:red", "cpu0",},
|
|
{ "assabet:green", "heartbeat", },
|
|
};
|
|
|
|
/*
|
|
* The LED control in Assabet is reversed:
|
|
* - setting bit means turn off LED
|
|
* - clearing bit means turn on LED
|
|
*/
|
|
static void assabet_led_set(struct led_classdev *cdev,
|
|
enum led_brightness b)
|
|
{
|
|
struct assabet_led *led = container_of(cdev,
|
|
struct assabet_led, cdev);
|
|
|
|
if (b != LED_OFF)
|
|
ASSABET_BCR_clear(led->mask);
|
|
else
|
|
ASSABET_BCR_set(led->mask);
|
|
}
|
|
|
|
static enum led_brightness assabet_led_get(struct led_classdev *cdev)
|
|
{
|
|
struct assabet_led *led = container_of(cdev,
|
|
struct assabet_led, cdev);
|
|
|
|
return (ASSABET_BCR & led->mask) ? LED_OFF : LED_FULL;
|
|
}
|
|
|
|
static int __init assabet_leds_init(void)
|
|
{
|
|
int i;
|
|
|
|
if (!machine_is_assabet())
|
|
return -ENODEV;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(assabet_leds); i++) {
|
|
struct assabet_led *led;
|
|
|
|
led = kzalloc(sizeof(*led), GFP_KERNEL);
|
|
if (!led)
|
|
break;
|
|
|
|
led->cdev.name = assabet_leds[i].name;
|
|
led->cdev.brightness_set = assabet_led_set;
|
|
led->cdev.brightness_get = assabet_led_get;
|
|
led->cdev.default_trigger = assabet_leds[i].trigger;
|
|
|
|
if (!i)
|
|
led->mask = ASSABET_BCR_LED_RED;
|
|
else
|
|
led->mask = ASSABET_BCR_LED_GREEN;
|
|
|
|
if (led_classdev_register(NULL, &led->cdev) < 0) {
|
|
kfree(led);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Since we may have triggers on any subsystem, defer registration
|
|
* until after subsystem_init.
|
|
*/
|
|
fs_initcall(assabet_leds_init);
|
|
#endif
|
|
|
|
MACHINE_START(ASSABET, "Intel-Assabet")
|
|
.atag_offset = 0x100,
|
|
.fixup = fixup_assabet,
|
|
.map_io = assabet_map_io,
|
|
.nr_irqs = SA1100_NR_IRQS,
|
|
.init_irq = sa1100_init_irq,
|
|
.init_time = sa1100_timer_init,
|
|
.init_machine = assabet_init,
|
|
.init_late = sa11x0_init_late,
|
|
#ifdef CONFIG_SA1111
|
|
.dma_zone_size = SZ_1M,
|
|
#endif
|
|
.restart = sa11x0_restart,
|
|
MACHINE_END
|