poodle.c 10.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * 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>
19
#include <linux/export.h>
20
#include <linux/platform_device.h>
Linus Torvalds's avatar
Linus Torvalds committed
21
#include <linux/fb.h>
22
#include <linux/pm.h>
23
#include <linux/delay.h>
24
#include <linux/mtd/physmap.h>
25
#include <linux/gpio.h>
26
#include <linux/i2c.h>
27
#include <linux/i2c/pxa-i2c.h>
28 29
#include <linux/spi/spi.h>
#include <linux/spi/ads7846.h>
30
#include <linux/spi/pxa2xx_spi.h>
31
#include <linux/mtd/sharpsl.h>
Laura Abbott's avatar
Laura Abbott committed
32
#include <linux/memblock.h>
Linus Torvalds's avatar
Linus Torvalds committed
33

34
#include <mach/hardware.h>
Linus Torvalds's avatar
Linus Torvalds committed
35 36 37 38 39 40 41 42
#include <asm/mach-types.h>
#include <asm/irq.h>
#include <asm/setup.h>

#include <asm/mach/arch.h>
#include <asm/mach/map.h>
#include <asm/mach/irq.h>

43
#include <mach/pxa25x.h>
44
#include <linux/platform_data/mmc-pxamci.h>
45
#include <mach/udc.h>
46
#include <linux/platform_data/irda-pxaficp.h>
47
#include <mach/poodle.h>
48
#include <linux/platform_data/video-pxafb.h>
Linus Torvalds's avatar
Linus Torvalds committed
49 50 51 52 53 54

#include <asm/hardware/scoop.h>
#include <asm/hardware/locomo.h>
#include <asm/mach/sharpsl_param.h>

#include "generic.h"
55
#include "devices.h"
Linus Torvalds's avatar
Linus Torvalds committed
56

57 58 59 60 61 62 63 64 65 66 67 68 69
static unsigned long poodle_pin_config[] __initdata = {
	/* I/O */
	GPIO79_nCS_3,
	GPIO80_nCS_4,
	GPIO18_RDY,

	/* Clock */
	GPIO12_32KHz,

	/* SSP1 */
	GPIO23_SSP1_SCLK,
	GPIO25_SSP1_TXD,
	GPIO26_SSP1_RXD,
70
	GPIO24_GPIO,	/* POODLE_GPIO_TP_CS - SFRM as chip select */
71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

	/* I2S */
	GPIO28_I2S_BITCLK_OUT,
	GPIO29_I2S_SDATA_IN,
	GPIO30_I2S_SDATA_OUT,
	GPIO31_I2S_SYNC,
	GPIO32_I2S_SYSCLK,

	/* Infra-Red */
	GPIO47_FICP_TXD,
	GPIO46_FICP_RXD,

	/* FFUART */
	GPIO40_FFUART_DTR,
	GPIO41_FFUART_RTS,
	GPIO39_FFUART_TXD,
	GPIO37_FFUART_DSR,
	GPIO34_FFUART_RXD,
	GPIO35_FFUART_CTS,

	/* LCD */
92
	GPIOxx_LCD_TFT_16BPP,
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119

	/* PC Card */
	GPIO48_nPOE,
	GPIO49_nPWE,
	GPIO50_nPIOR,
	GPIO51_nPIOW,
	GPIO52_nPCE_1,
	GPIO53_nPCE_2,
	GPIO54_nPSKTSEL,
	GPIO55_nPREG,
	GPIO56_nPWAIT,
	GPIO57_nIOIS16,

	/* MMC */
	GPIO6_MMC_CLK,
	GPIO8_MMC_CS0,

	/* GPIO */
	GPIO9_GPIO,	/* POODLE_GPIO_nSD_DETECT */
	GPIO7_GPIO,	/* POODLE_GPIO_nSD_WP */
	GPIO3_GPIO,	/* POODLE_GPIO_SD_PWR */
	GPIO33_GPIO,	/* POODLE_GPIO_SD_PWR1 */

	GPIO20_GPIO,	/* POODLE_GPIO_USB_PULLUP */
	GPIO22_GPIO,	/* POODLE_GPIO_IR_ON */
};

Linus Torvalds's avatar
Linus Torvalds committed
120 121 122 123 124 125 126 127 128 129 130
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,
131
	.gpio_base	= POODLE_SCOOP_GPIO_BASE,
Linus Torvalds's avatar
Linus Torvalds committed
132 133 134 135 136 137 138 139 140 141 142 143
};

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,
};

144 145 146 147 148 149 150 151 152
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",
},
};

153 154 155 156 157 158 159
static struct scoop_pcmcia_config poodle_pcmcia_config = {
	.devs         = &poodle_pcmcia_scoop[0],
	.num_devs     = 1,
};

EXPORT_SYMBOL(poodle_scoop_device);

Linus Torvalds's avatar
Linus Torvalds committed
160

161 162 163 164 165
static struct platform_device poodle_audio_device = {
	.name	= "poodle-audio",
	.id	= -1,
};

Linus Torvalds's avatar
Linus Torvalds committed
166 167 168 169 170 171 172 173
/* LoCoMo device */
static struct resource locomo_resources[] = {
	[0] = {
		.start		= 0x10000000,
		.end		= 0x10001fff,
		.flags		= IORESOURCE_MEM,
	},
	[1] = {
174 175
		.start		= PXA_GPIO_TO_IRQ(10),
		.end		= PXA_GPIO_TO_IRQ(10),
Linus Torvalds's avatar
Linus Torvalds committed
176 177 178 179
		.flags		= IORESOURCE_IRQ,
	},
};

180 181 182 183
static struct locomo_platform_data locomo_info = {
	.irq_base	= IRQ_BOARD_START,
};

184
struct platform_device poodle_locomo_device = {
Linus Torvalds's avatar
Linus Torvalds committed
185 186 187 188
	.name		= "locomo",
	.id		= 0,
	.num_resources	= ARRAY_SIZE(locomo_resources),
	.resource	= locomo_resources,
189 190 191
	.dev		= {
		.platform_data	= &locomo_info,
	},
Linus Torvalds's avatar
Linus Torvalds committed
192 193
};

194 195
EXPORT_SYMBOL(poodle_locomo_device);

196 197 198
#if defined(CONFIG_SPI_PXA2XX) || defined(CONFIG_SPI_PXA2XX_MODULE)
static struct pxa2xx_spi_master poodle_spi_info = {
	.num_chipselect	= 1,
199 200
};

201 202 203 204 205 206
static struct ads7846_platform_data poodle_ads7846_info = {
	.model			= 7846,
	.vref_delay_usecs	= 100,
	.x_plate_ohms		= 419,
	.y_plate_ohms		= 486,
	.gpio_pendown		= POODLE_GPIO_TP_INT,
207 208
};

209
static struct pxa2xx_spi_chip poodle_ads7846_chip = {
210
	.gpio_cs		= POODLE_GPIO_TP_CS,
211 212
};

213 214 215 216 217 218 219
static struct spi_board_info poodle_spi_devices[] = {
	{
		.modalias	= "ads7846",
		.max_speed_hz	= 10000,
		.bus_num	= 1,
		.platform_data	= &poodle_ads7846_info,
		.controller_data= &poodle_ads7846_chip,
220
		.irq		= PXA_GPIO_TO_IRQ(POODLE_GPIO_TP_INT),
221 222 223
	},
};

224 225 226 227 228 229 230 231
static void __init poodle_init_spi(void)
{
	pxa2xx_set_spi_info(1, &poodle_spi_info);
	spi_register_board_info(ARRAY_AND_SIZE(poodle_spi_devices));
}
#else
static inline void poodle_init_spi(void) {}
#endif
232 233 234 235 236 237 238

/*
 * 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.
 */
239
static int poodle_mci_init(struct device *dev, irq_handler_t poodle_detect_int, void *data)
240 241 242
{
	int err;

243 244 245 246 247 248 249 250 251 252
	err = gpio_request(POODLE_GPIO_SD_PWR, "SD_PWR");
	if (err)
		goto err_free_2;

	err = gpio_request(POODLE_GPIO_SD_PWR1, "SD_PWR1");
	if (err)
		goto err_free_3;

	gpio_direction_output(POODLE_GPIO_SD_PWR, 0);
	gpio_direction_output(POODLE_GPIO_SD_PWR1, 0);
253

254
	return 0;
255

256 257 258
err_free_3:
	gpio_free(POODLE_GPIO_SD_PWR);
err_free_2:
259
	return err;
260 261
}

262
static int poodle_mci_setpower(struct device *dev, unsigned int vdd)
263 264 265
{
	struct pxamci_platform_data* p_d = dev->platform_data;

266 267
	if ((1 << vdd) & p_d->ocr_mask) {
		gpio_set_value(POODLE_GPIO_SD_PWR, 1);
268
		mdelay(2);
269
		gpio_set_value(POODLE_GPIO_SD_PWR1, 1);
270
	} else {
271 272
		gpio_set_value(POODLE_GPIO_SD_PWR1, 0);
		gpio_set_value(POODLE_GPIO_SD_PWR, 0);
273
	}
274 275

	return 0;
276 277
}

278 279
static void poodle_mci_exit(struct device *dev, void *data)
{
280 281
	gpio_free(POODLE_GPIO_SD_PWR1);
	gpio_free(POODLE_GPIO_SD_PWR);
282 283 284
}

static struct pxamci_platform_data poodle_mci_platform_data = {
285
	.detect_delay_ms	= 250,
286 287 288 289
	.ocr_mask		= MMC_VDD_32_33|MMC_VDD_33_34,
	.init 			= poodle_mci_init,
	.setpower 		= poodle_mci_setpower,
	.exit			= poodle_mci_exit,
290
	.gpio_card_detect	= POODLE_GPIO_nSD_DETECT,
291 292
	.gpio_card_ro		= POODLE_GPIO_nSD_WP,
	.gpio_power		= -1,
293 294 295
};


296 297 298 299
/*
 * Irda
 */
static struct pxaficp_platform_data poodle_ficp_platform_data = {
300
	.gpio_pwdown		= POODLE_GPIO_IR_ON,
301
	.transceiver_cap	= IR_SIRMODE | IR_OFF,
302 303 304
};


305 306 307 308 309
/*
 * USB Device Controller
 */
static struct pxa2xx_udc_mach_info udc_info __initdata = {
	/* no connect GPIO; poodle can't tell connection status */
310
	.gpio_pullup	= POODLE_GPIO_USB_PULLUP,
311 312 313
};


Linus Torvalds's avatar
Linus Torvalds committed
314
/* PXAFB device */
315
static struct pxafb_mode_info poodle_fb_mode = {
Linus Torvalds's avatar
Linus Torvalds committed
316 317 318 319 320 321 322 323 324 325 326
	.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,
327
};
Linus Torvalds's avatar
Linus Torvalds committed
328

329 330 331
static struct pxafb_mach_info poodle_fb_info = {
	.modes		= &poodle_fb_mode,
	.num_modes	= 1,
332
	.lcd_conn	= LCD_COLOR_TFT_16BPP,
Linus Torvalds's avatar
Linus Torvalds committed
333 334
};

335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
static struct mtd_partition sharpsl_nand_partitions[] = {
	{
		.name = "System Area",
		.offset = 0,
		.size = 7 * 1024 * 1024,
	},
	{
		.name = "Root Filesystem",
		.offset = 7 * 1024 * 1024,
		.size = 22 * 1024 * 1024,
	},
	{
		.name = "Home Filesystem",
		.offset = MTDPART_OFS_APPEND,
		.size = MTDPART_SIZ_FULL,
	},
};

static uint8_t scan_ff_pattern[] = { 0xff, 0xff };

static struct nand_bbt_descr sharpsl_bbt = {
	.options = 0,
	.offs = 4,
	.len = 2,
	.pattern = scan_ff_pattern
};

static struct sharpsl_nand_platform_data sharpsl_nand_platform_data = {
	.badblock_pattern	= &sharpsl_bbt,
	.partitions		= sharpsl_nand_partitions,
	.nr_partitions		= ARRAY_SIZE(sharpsl_nand_partitions),
};

static struct resource sharpsl_nand_resources[] = {
	{
		.start	= 0x0C000000,
		.end	= 0x0C000FFF,
		.flags	= IORESOURCE_MEM,
	},
};

static struct platform_device sharpsl_nand_device = {
	.name		= "sharpsl-nand",
	.id		= -1,
	.resource	= sharpsl_nand_resources,
	.num_resources	= ARRAY_SIZE(sharpsl_nand_resources),
	.dev.platform_data	= &sharpsl_nand_platform_data,
};

384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
static struct mtd_partition sharpsl_rom_parts[] = {
	{
		.name	="Boot PROM Filesystem",
		.offset	= 0x00120000,
		.size	= MTDPART_SIZ_FULL,
	},
};

static struct physmap_flash_data sharpsl_rom_data = {
	.width		= 2,
	.nr_parts	= ARRAY_SIZE(sharpsl_rom_parts),
	.parts		= sharpsl_rom_parts,
};

static struct resource sharpsl_rom_resources[] = {
	{
		.start	= 0x00000000,
		.end	= 0x007fffff,
		.flags	= IORESOURCE_MEM,
	},
};

static struct platform_device sharpsl_rom_device = {
	.name	= "physmap-flash",
	.id	= -1,
	.resource = sharpsl_rom_resources,
	.num_resources = ARRAY_SIZE(sharpsl_rom_resources),
	.dev.platform_data = &sharpsl_rom_data,
};

Linus Torvalds's avatar
Linus Torvalds committed
414
static struct platform_device *devices[] __initdata = {
415
	&poodle_locomo_device,
Linus Torvalds's avatar
Linus Torvalds committed
416
	&poodle_scoop_device,
417
	&poodle_audio_device,
418
	&sharpsl_nand_device,
419
	&sharpsl_rom_device,
Linus Torvalds's avatar
Linus Torvalds committed
420 421
};

422 423 424 425
static struct i2c_board_info __initdata poodle_i2c_devices[] = {
	{ I2C_BOARD_INFO("wm8731", 0x1b) },
};

426 427
static void poodle_poweroff(void)
{
428
	pxa_restart(REBOOT_HARD, NULL);
429 430
}

Linus Torvalds's avatar
Linus Torvalds committed
431 432 433 434
static void __init poodle_init(void)
{
	int ret = 0;

435 436
	pm_power_off = poodle_poweroff;

437 438
	PCFR |= PCFR_OPDE;

439
	pxa2xx_mfp_config(ARRAY_AND_SIZE(poodle_pin_config));
Linus Torvalds's avatar
Linus Torvalds committed
440

441 442 443 444
	pxa_set_ffuart_info(NULL);
	pxa_set_btuart_info(NULL);
	pxa_set_stuart_info(NULL);

445 446 447 448 449 450
	platform_scoop_config = &poodle_pcmcia_config;

	ret = platform_add_devices(devices, ARRAY_SIZE(devices));
	if (ret)
		pr_warning("poodle: Unable to register LoCoMo device\n");

451
	pxa_set_fb_info(&poodle_locomo_device.dev, &poodle_fb_info);
452 453
	pxa_set_udc_info(&udc_info);
	pxa_set_mci_info(&poodle_mci_platform_data);
454
	pxa_set_ficp_info(&poodle_ficp_platform_data);
455
	pxa_set_i2c_info(NULL);
456
	i2c_register_board_info(0, ARRAY_AND_SIZE(poodle_i2c_devices));
457
	poodle_init_spi();
Linus Torvalds's avatar
Linus Torvalds committed
458 459
}

Laura Abbott's avatar
Laura Abbott committed
460
static void __init fixup_poodle(struct tag *tags, char **cmdline)
Linus Torvalds's avatar
Linus Torvalds committed
461 462
{
	sharpsl_save_param();
Laura Abbott's avatar
Laura Abbott committed
463
	memblock_add(0xa0000000, SZ_32M);
Linus Torvalds's avatar
Linus Torvalds committed
464 465 466
}

MACHINE_START(POODLE, "SHARP Poodle")
467
	.fixup		= fixup_poodle,
468
	.map_io		= pxa25x_map_io,
469
	.nr_irqs	= POODLE_NR_IRQS,	/* 4 for LoCoMo */
470
	.init_irq	= pxa25x_init_irq,
471
	.handle_irq	= pxa25x_handle_irq,
Stephen Warren's avatar
Stephen Warren committed
472
	.init_time	= pxa_timer_init,
473
	.init_machine	= poodle_init,
474
	.restart	= pxa_restart,
Linus Torvalds's avatar
Linus Torvalds committed
475
MACHINE_END