simpad.c 8.78 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9
/*
 * linux/arch/arm/mach-sa1100/simpad.c
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/tty.h>
#include <linux/proc_fs.h>
10
#include <linux/string.h>
Linus Torvalds's avatar
Linus Torvalds committed
11
#include <linux/pm.h>
12
#include <linux/platform_data/sa11x0-serial.h>
13
#include <linux/platform_device.h>
14
#include <linux/mfd/ucb1x00.h>
Linus Torvalds's avatar
Linus Torvalds committed
15 16
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
17
#include <linux/io.h>
18
#include <linux/gpio/driver.h>
19
#include <linux/gpio/machine.h>
Linus Torvalds's avatar
Linus Torvalds committed
20

21
#include <mach/hardware.h>
Linus Torvalds's avatar
Linus Torvalds committed
22
#include <asm/setup.h>
23
#include <asm/irq.h>
Linus Torvalds's avatar
Linus Torvalds committed
24 25 26 27 28

#include <asm/mach-types.h>
#include <asm/mach/arch.h>
#include <asm/mach/flash.h>
#include <asm/mach/map.h>
29
#include <linux/platform_data/mfd-mcp-sa11x0.h>
30
#include <mach/simpad.h>
31
#include <mach/irqs.h>
Linus Torvalds's avatar
Linus Torvalds committed
32 33 34

#include <linux/serial_core.h>
#include <linux/ioport.h>
35 36
#include <linux/input.h>
#include <linux/gpio_keys.h>
37
#include <linux/leds.h>
38
#include <linux/i2c-gpio.h>
Linus Torvalds's avatar
Linus Torvalds committed
39 40 41

#include "generic.h"

42 43 44 45 46 47 48 49 50 51 52 53 54
/*
 * CS3 support
 */

static long cs3_shadow;
static spinlock_t cs3_lock;
static struct gpio_chip cs3_gpio;

long simpad_get_cs3_ro(void)
{
	return readl(CS3_BASE);
}
EXPORT_SYMBOL(simpad_get_cs3_ro);
Linus Torvalds's avatar
Linus Torvalds committed
55

56
long simpad_get_cs3_shadow(void)
Linus Torvalds's avatar
Linus Torvalds committed
57 58 59
{
	return cs3_shadow;
}
60
EXPORT_SYMBOL(simpad_get_cs3_shadow);
Linus Torvalds's avatar
Linus Torvalds committed
61

62
static void __simpad_write_cs3(void)
Linus Torvalds's avatar
Linus Torvalds committed
63
{
64
	writel(cs3_shadow, CS3_BASE);
Linus Torvalds's avatar
Linus Torvalds committed
65 66
}

67
void simpad_set_cs3_bit(int value)
Linus Torvalds's avatar
Linus Torvalds committed
68
{
69 70 71
	unsigned long flags;

	spin_lock_irqsave(&cs3_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
72
	cs3_shadow |= value;
73 74
	__simpad_write_cs3();
	spin_unlock_irqrestore(&cs3_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
75
}
76
EXPORT_SYMBOL(simpad_set_cs3_bit);
Linus Torvalds's avatar
Linus Torvalds committed
77

78
void simpad_clear_cs3_bit(int value)
Linus Torvalds's avatar
Linus Torvalds committed
79
{
80 81 82
	unsigned long flags;

	spin_lock_irqsave(&cs3_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
83
	cs3_shadow &= ~value;
84 85
	__simpad_write_cs3();
	spin_unlock_irqrestore(&cs3_lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
86
}
87 88 89 90 91 92 93 94 95 96 97
EXPORT_SYMBOL(simpad_clear_cs3_bit);

static void cs3_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
{
	if (offset > 15)
		return;
	if (value)
		simpad_set_cs3_bit(1 << offset);
	else
		simpad_clear_cs3_bit(1 << offset);
};
Linus Torvalds's avatar
Linus Torvalds committed
98

99 100 101
static int cs3_gpio_get(struct gpio_chip *chip, unsigned offset)
{
	if (offset > 15)
102 103
		return !!(simpad_get_cs3_ro() & (1 << (offset - 16)));
	return !!(simpad_get_cs3_shadow() & (1 << offset));
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
};

static int cs3_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
{
	if (offset > 15)
		return 0;
	return -EINVAL;
};

static int cs3_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
	int value)
{
	if (offset > 15)
		return -EINVAL;
	cs3_gpio_set(chip, offset, value);
	return 0;
};
Linus Torvalds's avatar
Linus Torvalds committed
121 122

static struct map_desc simpad_io_desc[] __initdata = {
123 124 125 126 127
	{	/* MQ200 */
		.virtual	=  0xf2800000,
		.pfn		= __phys_to_pfn(0x4b800000),
		.length		= 0x00800000,
		.type		= MT_DEVICE
128
	}, {	/* Simpad CS3 */
129
		.virtual	= (unsigned long)CS3_BASE,
130
		.pfn		= __phys_to_pfn(SA1100_CS3_PHYS),
131 132 133
		.length		= 0x00100000,
		.type		= MT_DEVICE
	},
Linus Torvalds's avatar
Linus Torvalds committed
134 135 136 137 138 139 140 141
};


static void simpad_uart_pm(struct uart_port *port, u_int state, u_int oldstate)
{
	if (port->mapbase == (u_int)&Ser1UTCR0) {
		if (state)
		{
142 143
			simpad_clear_cs3_bit(RS232_ON);
			simpad_clear_cs3_bit(DECT_POWER_ON);
Linus Torvalds's avatar
Linus Torvalds committed
144 145
		}else
		{
146 147
			simpad_set_cs3_bit(RS232_ON);
			simpad_set_cs3_bit(DECT_POWER_ON);
Linus Torvalds's avatar
Linus Torvalds committed
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
		}
	}
}

static struct sa1100_port_fns simpad_port_fns __initdata = {
	.pm	   = simpad_uart_pm,
};


static struct mtd_partition simpad_partitions[] = {
	{
		.name       = "SIMpad boot firmware",
		.size       = 0x00080000,
		.offset     = 0,
		.mask_flags = MTD_WRITEABLE,
	}, {
		.name       = "SIMpad kernel",
		.size       = 0x0010000,
		.offset     = MTDPART_OFS_APPEND,
	}, {
		.name       = "SIMpad root jffs2",
		.size       = MTDPART_SIZ_FULL,
		.offset     = MTDPART_OFS_APPEND,
	}
};

static struct flash_platform_data simpad_flash_data = {
	.map_name    = "cfi_probe",
	.parts       = simpad_partitions,
	.nr_parts    = ARRAY_SIZE(simpad_partitions),
};


static struct resource simpad_flash_resources [] = {
182 183
	DEFINE_RES_MEM(SA1100_CS0_PHYS, SZ_16M),
	DEFINE_RES_MEM(SA1100_CS1_PHYS, SZ_16M),
Linus Torvalds's avatar
Linus Torvalds committed
184 185
};

186 187 188 189
static struct ucb1x00_plat_data simpad_ucb1x00_data = {
	.gpio_base	= SIMPAD_UCB1X00_GPIO_BASE,
};

190 191 192
static struct mcp_plat_data simpad_mcp_data = {
	.mccr0		= MCCR0_ADM,
	.sclk_rate	= 11981000,
193
	.codec_pdata	= &simpad_ucb1x00_data,
194 195
};

Linus Torvalds's avatar
Linus Torvalds committed
196 197 198 199 200 201 202 203


static void __init simpad_map_io(void)
{
	sa1100_map_io();

	iotable_init(simpad_io_desc, ARRAY_SIZE(simpad_io_desc));

204 205 206 207
	/* Initialize CS3 */
	cs3_shadow = (EN1 | EN0 | LED2_ON | DISPLAY_ON |
		RS232_ON | ENABLE_5V | RESET_SIMCARD | DECT_POWER_ON);
	__simpad_write_cs3(); /* Spinlocks not yet initialized */
Linus Torvalds's avatar
Linus Torvalds committed
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232

        sa1100_register_uart_fns(&simpad_port_fns);
	sa1100_register_uart(0, 3);  /* serial interface */
	sa1100_register_uart(1, 1);  /* DECT             */

	// Reassign UART 1 pins
	GAFR |= GPIO_UART_TXD | GPIO_UART_RXD;
	GPDR |= GPIO_UART_TXD | GPIO_LDD13 | GPIO_LDD15;
	GPDR &= ~GPIO_UART_RXD;
	PPAR |= PPAR_UPR;

	/*
	 * Set up registers for sleep mode.
	 */


	PWER = PWER_GPIO0| PWER_RTC;
	PGSR = 0x818;
	PCFR = 0;
	PSDR = 0;

}

static void simpad_power_off(void)
{
233 234 235
	local_irq_disable();
	cs3_shadow = SD_MEDIAQ;
	__simpad_write_cs3(); /* Bypass spinlock here */
Linus Torvalds's avatar
Linus Torvalds committed
236 237 238

	/* disable internal oscillator, float CS lines */
	PCFR = (PCFR_OPDE | PCFR_FP | PCFR_FS);
239 240
	/* enable wake-up on GPIO0 */
	PWER = GFER = GRER = PWER_GPIO0;
Linus Torvalds's avatar
Linus Torvalds committed
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
	/*
	 * set scratchpad to zero, just in case it is used as a
	 * restart address by the bootloader.
	 */
	PSPR = 0;
	PGSR = 0;
	/* enter sleep mode */
	PMCR = PMCR_SF;
	while(1);

	local_irq_enable(); /* we won't ever call it */


}

256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
/*
 * gpio_keys
*/

static struct gpio_keys_button simpad_button_table[] = {
	{ KEY_POWER, IRQ_GPIO_POWER_BUTTON, 1, "power button" },
};

static struct gpio_keys_platform_data simpad_keys_data = {
	.buttons = simpad_button_table,
	.nbuttons = ARRAY_SIZE(simpad_button_table),
};

static struct platform_device simpad_keys = {
	.name = "gpio-keys",
	.dev = {
		.platform_data = &simpad_keys_data,
	},
};

static struct gpio_keys_button simpad_polled_button_table[] = {
	{ KEY_PROG1, SIMPAD_UCB1X00_GPIO_PROG1, 1, "prog1 button" },
	{ KEY_PROG2, SIMPAD_UCB1X00_GPIO_PROG2, 1, "prog2 button" },
	{ KEY_UP,    SIMPAD_UCB1X00_GPIO_UP,    1, "up button" },
	{ KEY_DOWN,  SIMPAD_UCB1X00_GPIO_DOWN,  1, "down button" },
	{ KEY_LEFT,  SIMPAD_UCB1X00_GPIO_LEFT,  1, "left button" },
	{ KEY_RIGHT, SIMPAD_UCB1X00_GPIO_RIGHT, 1, "right button" },
};

static struct gpio_keys_platform_data simpad_polled_keys_data = {
	.buttons = simpad_polled_button_table,
	.nbuttons = ARRAY_SIZE(simpad_polled_button_table),
	.poll_interval = 50,
};

static struct platform_device simpad_polled_keys = {
	.name = "gpio-keys-polled",
	.dev = {
		.platform_data = &simpad_polled_keys_data,
	},
};

298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
/*
 * GPIO LEDs
 */

static struct gpio_led simpad_leds[] = {
	{
		.name = "simpad:power",
		.gpio = SIMPAD_CS3_LED2_ON,
		.active_low = 0,
		.default_trigger = "default-on",
	},
};

static struct gpio_led_platform_data simpad_led_data = {
	.num_leds = ARRAY_SIZE(simpad_leds),
	.leds = simpad_leds,
};

static struct platform_device simpad_gpio_leds = {
	.name = "leds-gpio",
	.id = 0,
	.dev = {
		.platform_data = &simpad_led_data,
	},
};

324 325 326
/*
 * i2c
 */
327 328 329 330 331 332 333 334
static struct gpiod_lookup_table simpad_i2c_gpiod_table = {
	.dev_id = "i2c-gpio",
	.table = {
		GPIO_LOOKUP_IDX("gpio", GPIO_GPIO21, NULL, 0, GPIO_ACTIVE_HIGH),
		GPIO_LOOKUP_IDX("gpio", GPIO_GPIO25, NULL, 1, GPIO_ACTIVE_HIGH),
	},
};

335 336 337 338 339 340 341 342 343 344 345 346
static struct i2c_gpio_platform_data simpad_i2c_data = {
	.udelay = 10,
	.timeout = HZ,
};

static struct platform_device simpad_i2c = {
	.name = "i2c-gpio",
	.id = 0,
	.dev = {
		.platform_data = &simpad_i2c_data,
	},
};
Linus Torvalds's avatar
Linus Torvalds committed
347 348 349 350 351 352 353 354 355 356

/*
 * MediaQ Video Device
 */
static struct platform_device simpad_mq200fb = {
	.name = "simpad-mq200",
	.id   = 0,
};

static struct platform_device *devices[] __initdata = {
357 358 359
	&simpad_keys,
	&simpad_polled_keys,
	&simpad_mq200fb,
360
	&simpad_gpio_leds,
361
	&simpad_i2c,
Linus Torvalds's avatar
Linus Torvalds committed
362 363 364 365 366 367 368 369
};



static int __init simpad_init(void)
{
	int ret;

370 371 372 373 374 375 376 377 378
	spin_lock_init(&cs3_lock);

	cs3_gpio.label = "simpad_cs3";
	cs3_gpio.base = SIMPAD_CS3_GPIO_BASE;
	cs3_gpio.ngpio = 24;
	cs3_gpio.set = cs3_gpio_set;
	cs3_gpio.get = cs3_gpio_get;
	cs3_gpio.direction_input = cs3_gpio_direction_input;
	cs3_gpio.direction_output = cs3_gpio_direction_output;
379
	ret = gpiochip_add_data(&cs3_gpio, NULL);
380 381 382
	if (ret)
		printk(KERN_WARNING "simpad: Unable to register cs3 GPIO device");

Linus Torvalds's avatar
Linus Torvalds committed
383 384
	pm_power_off = simpad_power_off;

385
	sa11x0_ppc_configure_mcp();
386 387 388 389
	sa11x0_register_mtd(&simpad_flash_data, simpad_flash_resources,
			      ARRAY_SIZE(simpad_flash_resources));
	sa11x0_register_mcp(&simpad_mcp_data);

390
	gpiod_add_lookup_table(&simpad_i2c_gpiod_table);
Linus Torvalds's avatar
Linus Torvalds committed
391 392 393 394 395 396 397 398 399 400 401
	ret = platform_add_devices(devices, ARRAY_SIZE(devices));
	if(ret)
		printk(KERN_WARNING "simpad: Unable to register mq200 framebuffer device");

	return 0;
}

arch_initcall(simpad_init);


MACHINE_START(SIMPAD, "Simpad")
402
	/* Maintainer: Holger Freyther */
403
	.atag_offset	= 0x100,
404
	.map_io		= simpad_map_io,
405
	.nr_irqs	= SA1100_NR_IRQS,
406
	.init_irq	= sa1100_init_irq,
407
	.init_late	= sa11x0_init_late,
408
	.init_time	= sa1100_timer_init,
409
	.restart	= sa11x0_restart,
Linus Torvalds's avatar
Linus Torvalds committed
410
MACHINE_END