mach-crag6410.c 21 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/* linux/arch/arm/mach-s3c64xx/mach-crag6410.c
 *
 * Copyright 2011 Wolfson Microelectronics plc
 *	Mark Brown <broonie@opensource.wolfsonmicro.com>
 *
 * Copyright 2011 Simtec Electronics
 *	Ben Dooks <ben@simtec.co.uk>
 *
 * 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/list.h>
#include <linux/serial_core.h>
#include <linux/platform_device.h>
#include <linux/fb.h>
#include <linux/io.h>
#include <linux/init.h>
#include <linux/gpio.h>
22
#include <linux/leds.h>
23
#include <linux/delay.h>
24
#include <linux/mmc/host.h>
25
#include <linux/regulator/machine.h>
26
#include <linux/regulator/fixed.h>
27 28 29 30 31 32 33
#include <linux/pwm_backlight.h>
#include <linux/dm9000.h>
#include <linux/gpio_keys.h>
#include <linux/basic_mmio_gpio.h>
#include <linux/spi/spi.h>

#include <linux/i2c/pca953x.h>
34
#include <linux/platform_data/s3c-hsotg.h>
35 36 37 38 39

#include <video/platform_lcd.h>

#include <linux/mfd/wm831x/core.h>
#include <linux/mfd/wm831x/pdata.h>
40
#include <linux/mfd/wm831x/irq.h>
41 42
#include <linux/mfd/wm831x/gpio.h>

43 44
#include <sound/wm1250-ev1.h>

45 46 47
#include <asm/mach/arch.h>
#include <asm/mach-types.h>

48
#include <video/samsung_fimd.h>
49 50 51 52 53 54 55 56 57
#include <mach/hardware.h>
#include <mach/map.h>

#include <mach/regs-gpio.h>

#include <plat/regs-serial.h>
#include <plat/fb.h>
#include <plat/sdhci.h>
#include <plat/gpio-cfg.h>
58
#include <linux/platform_data/spi-s3c64xx.h>
59 60 61 62 63 64

#include <plat/keypad.h>
#include <plat/clock.h>
#include <plat/devs.h>
#include <plat/cpu.h>
#include <plat/adc.h>
65
#include <linux/platform_data/i2c-s3c2410.h>
66
#include <plat/pm.h>
67
#include <plat/samsung-time.h>
68

69
#include "common.h"
70
#include "crag6410.h"
71
#include "regs-gpio-memport.h"
72
#include "regs-modem.h"
73
#include "regs-sys.h"
74

75 76 77 78 79 80 81 82
/* serial port setup */

#define UCON (S3C2410_UCON_DEFAULT | S3C2410_UCON_UCLK)
#define ULCON (S3C2410_LCON_CS8 | S3C2410_LCON_PNONE | S3C2410_LCON_STOPB)
#define UFCON (S3C2410_UFCON_RXTRIG8 | S3C2410_UFCON_FIFOMODE)

static struct s3c2410_uartcfg crag6410_uartcfgs[] __initdata = {
	[0] = {
83 84 85 86 87
		.hwport		= 0,
		.flags		= 0,
		.ucon		= UCON,
		.ulcon		= ULCON,
		.ufcon		= UFCON,
88 89
	},
	[1] = {
90 91 92 93 94
		.hwport		= 1,
		.flags		= 0,
		.ucon		= UCON,
		.ulcon		= ULCON,
		.ufcon		= UFCON,
95 96
	},
	[2] = {
97 98 99 100 101
		.hwport		= 2,
		.flags		= 0,
		.ucon		= UCON,
		.ulcon		= ULCON,
		.ufcon		= UFCON,
102 103
	},
	[3] = {
104 105 106 107 108
		.hwport		= 3,
		.flags		= 0,
		.ucon		= UCON,
		.ulcon		= ULCON,
		.ufcon		= UFCON,
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
	},
};

static struct platform_pwm_backlight_data crag6410_backlight_data = {
	.pwm_id		= 0,
	.max_brightness	= 1000,
	.dft_brightness	= 600,
	.pwm_period_ns	= 100000,	/* about 1kHz */
};

static struct platform_device crag6410_backlight_device = {
	.name		= "pwm-backlight",
	.id		= -1,
	.dev		= {
		.parent	= &s3c_device_timer[0].dev,
		.platform_data = &crag6410_backlight_data,
	},
};

static void crag6410_lcd_power_set(struct plat_lcd_data *pd, unsigned int power)
{
	pr_debug("%s: setting power %d\n", __func__, power);

	if (power) {
		gpio_set_value(S3C64XX_GPB(0), 1);
		msleep(1);
		s3c_gpio_cfgpin(S3C64XX_GPF(14), S3C_GPIO_SFN(2));
	} else {
		gpio_direction_output(S3C64XX_GPF(14), 0);
		gpio_set_value(S3C64XX_GPB(0), 0);
	}
}

static struct platform_device crag6410_lcd_powerdev = {
	.name			= "platform-lcd",
	.id			= -1,
	.dev.parent		= &s3c_device_fb.dev,
	.dev.platform_data	= &(struct plat_lcd_data) {
		.set_power	= crag6410_lcd_power_set,
	},
};

/* 640x480 URT */
static struct s3c_fb_pd_win crag6410_fb_win0 = {
	.max_bpp	= 32,
	.default_bpp	= 16,
155 156
	.xres		= 640,
	.yres		= 480,
157 158 159 160
	.virtual_y	= 480 * 2,
	.virtual_x	= 640,
};

161 162 163 164 165 166 167 168 169 170 171
static struct fb_videomode crag6410_lcd_timing = {
	.left_margin	= 150,
	.right_margin	= 80,
	.upper_margin	= 40,
	.lower_margin	= 5,
	.hsync_len	= 40,
	.vsync_len	= 5,
	.xres		= 640,
	.yres		= 480,
};

172
/* 405566 clocks per frame => 60Hz refresh requires 24333960Hz clock */
173
static struct s3c_fb_platdata crag6410_lcd_pdata = {
174
	.setup_gpio	= s3c64xx_fb_gpio_setup_24bpp,
175
	.vtiming	= &crag6410_lcd_timing,
176 177 178 179 180 181 182
	.win[0]		= &crag6410_fb_win0,
	.vidcon0	= VIDCON0_VIDOUT_RGB | VIDCON0_PNRMODE_RGB,
	.vidcon1	= VIDCON1_INV_HSYNC | VIDCON1_INV_VSYNC,
};

/* 2x6 keypad */

183
static uint32_t crag6410_keymap[] = {
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
	/* KEY(row, col, keycode) */
	KEY(0, 0, KEY_VOLUMEUP),
	KEY(0, 1, KEY_HOME),
	KEY(0, 2, KEY_VOLUMEDOWN),
	KEY(0, 3, KEY_HELP),
	KEY(0, 4, KEY_MENU),
	KEY(0, 5, KEY_MEDIA),
	KEY(1, 0, 232),
	KEY(1, 1, KEY_DOWN),
	KEY(1, 2, KEY_LEFT),
	KEY(1, 3, KEY_UP),
	KEY(1, 4, KEY_RIGHT),
	KEY(1, 5, KEY_CAMERA),
};

199
static struct matrix_keymap_data crag6410_keymap_data = {
200 201 202 203
	.keymap		= crag6410_keymap,
	.keymap_size	= ARRAY_SIZE(crag6410_keymap),
};

204
static struct samsung_keypad_platdata crag6410_keypad_data = {
205 206 207 208 209 210 211 212 213
	.keymap_data	= &crag6410_keymap_data,
	.rows		= 2,
	.cols		= 6,
};

static struct gpio_keys_button crag6410_gpio_keys[] = {
	[0] = {
		.code	= KEY_SUSPEND,
		.gpio	= S3C64XX_GPL(10),	/* EINT 18 */
214
		.type	= EV_KEY,
215 216 217
		.wakeup	= 1,
		.active_low = 1,
	},
218 219 220 221 222
	[1] = {
		.code	= SW_FRONT_PROXIMITY,
		.gpio	= S3C64XX_GPN(11),	/* EINT 11 */
		.type	= EV_SW,
	},
223 224 225 226 227 228 229 230 231 232 233 234 235 236
};

static struct gpio_keys_platform_data crag6410_gpio_keydata = {
	.buttons	= crag6410_gpio_keys,
	.nbuttons	= ARRAY_SIZE(crag6410_gpio_keys),
};

static struct platform_device crag6410_gpio_keydev = {
	.name		= "gpio-keys",
	.id		= 0,
	.dev.platform_data = &crag6410_gpio_keydata,
};

static struct resource crag6410_dm9k_resource[] = {
237 238 239 240
	[0] = DEFINE_RES_MEM(S3C64XX_PA_XM0CSN5, 2),
	[1] = DEFINE_RES_MEM(S3C64XX_PA_XM0CSN5 + (1 << 8), 2),
	[2] = DEFINE_RES_NAMED(S3C_EINT(17), 1, NULL, IORESOURCE_IRQ \
				| IORESOURCE_IRQ_HIGHLEVEL),
241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
};

static struct dm9000_plat_data mini6410_dm9k_pdata = {
	.flags	= DM9000_PLATF_16BITONLY,
};

static struct platform_device crag6410_dm9k_device = {
	.name		= "dm9000",
	.id		= -1,
	.num_resources	= ARRAY_SIZE(crag6410_dm9k_resource),
	.resource	= crag6410_dm9k_resource,
	.dev.platform_data = &mini6410_dm9k_pdata,
};

static struct resource crag6410_mmgpio_resource[] = {
256
	[0] = DEFINE_RES_MEM_NAMED(S3C64XX_PA_XM0CSN4, 1, "dat"),
257 258 259 260 261 262 263 264
};

static struct platform_device crag6410_mmgpio = {
	.name		= "basic-mmio-gpio",
	.id		= -1,
	.resource	= crag6410_mmgpio_resource,
	.num_resources	= ARRAY_SIZE(crag6410_mmgpio_resource),
	.dev.platform_data = &(struct bgpio_pdata) {
265
		.base	= MMGPIO_GPIO_BASE,
266 267 268
	},
};

269 270 271 272 273
static struct platform_device speyside_device = {
	.name		= "speyside",
	.id		= -1,
};

274 275 276 277 278
static struct platform_device lowland_device = {
	.name		= "lowland",
	.id		= -1,
};

279 280
static struct platform_device tobermory_device = {
	.name		= "tobermory",
281 282 283
	.id		= -1,
};

284 285 286 287 288
static struct platform_device littlemill_device = {
	.name		= "littlemill",
	.id		= -1,
};

289
static struct platform_device bells_wm2200_device = {
290 291 292 293
	.name		= "bells",
	.id		= 0,
};

294
static struct platform_device bells_wm5102_device = {
295 296 297 298
	.name		= "bells",
	.id		= 1,
};

299 300 301 302 303
static struct platform_device bells_wm5110_device = {
	.name		= "bells",
	.id		= 2,
};

304
static struct regulator_consumer_supply wallvdd_consumers[] = {
305
	REGULATOR_SUPPLY("SPKVDD", "1-001a"),
306 307
	REGULATOR_SUPPLY("SPKVDD1", "1-001a"),
	REGULATOR_SUPPLY("SPKVDD2", "1-001a"),
308 309
	REGULATOR_SUPPLY("SPKVDDL", "1-001a"),
	REGULATOR_SUPPLY("SPKVDDR", "1-001a"),
310

311 312 313 314 315 316 317
	REGULATOR_SUPPLY("SPKVDDL", "spi0.1"),
	REGULATOR_SUPPLY("SPKVDDR", "spi0.1"),
	REGULATOR_SUPPLY("SPKVDDL", "wm5102-codec"),
	REGULATOR_SUPPLY("SPKVDDR", "wm5102-codec"),
	REGULATOR_SUPPLY("SPKVDDL", "wm5110-codec"),
	REGULATOR_SUPPLY("SPKVDDR", "wm5110-codec"),

318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
	REGULATOR_SUPPLY("DC1VDD", "0-0034"),
	REGULATOR_SUPPLY("DC2VDD", "0-0034"),
	REGULATOR_SUPPLY("DC3VDD", "0-0034"),
	REGULATOR_SUPPLY("LDO1VDD", "0-0034"),
	REGULATOR_SUPPLY("LDO2VDD", "0-0034"),
	REGULATOR_SUPPLY("LDO4VDD", "0-0034"),
	REGULATOR_SUPPLY("LDO5VDD", "0-0034"),
	REGULATOR_SUPPLY("LDO6VDD", "0-0034"),
	REGULATOR_SUPPLY("LDO7VDD", "0-0034"),
	REGULATOR_SUPPLY("LDO8VDD", "0-0034"),
	REGULATOR_SUPPLY("LDO9VDD", "0-0034"),
	REGULATOR_SUPPLY("LDO10VDD", "0-0034"),
	REGULATOR_SUPPLY("LDO11VDD", "0-0034"),

	REGULATOR_SUPPLY("DC1VDD", "1-0034"),
	REGULATOR_SUPPLY("DC2VDD", "1-0034"),
	REGULATOR_SUPPLY("DC3VDD", "1-0034"),
335 336 337 338 339 340 341 342 343 344
	REGULATOR_SUPPLY("LDO1VDD", "1-0034"),
	REGULATOR_SUPPLY("LDO2VDD", "1-0034"),
	REGULATOR_SUPPLY("LDO4VDD", "1-0034"),
	REGULATOR_SUPPLY("LDO5VDD", "1-0034"),
	REGULATOR_SUPPLY("LDO6VDD", "1-0034"),
	REGULATOR_SUPPLY("LDO7VDD", "1-0034"),
	REGULATOR_SUPPLY("LDO8VDD", "1-0034"),
	REGULATOR_SUPPLY("LDO9VDD", "1-0034"),
	REGULATOR_SUPPLY("LDO10VDD", "1-0034"),
	REGULATOR_SUPPLY("LDO11VDD", "1-0034"),
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
};

static struct regulator_init_data wallvdd_data = {
	.constraints = {
		.always_on = 1,
	},
	.num_consumer_supplies = ARRAY_SIZE(wallvdd_consumers),
	.consumer_supplies = wallvdd_consumers,
};

static struct fixed_voltage_config wallvdd_pdata = {
	.supply_name = "WALLVDD",
	.microvolts = 5000000,
	.init_data = &wallvdd_data,
	.gpio = -EINVAL,
};

static struct platform_device wallvdd_device = {
	.name		= "reg-fixed-voltage",
	.id		= -1,
	.dev = {
		.platform_data = &wallvdd_pdata,
	},
};

370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
static struct platform_device *crag6410_devices[] __initdata = {
	&s3c_device_hsmmc0,
	&s3c_device_hsmmc2,
	&s3c_device_i2c0,
	&s3c_device_i2c1,
	&s3c_device_fb,
	&s3c_device_ohci,
	&s3c_device_usb_hsotg,
	&s3c_device_timer[0],
	&s3c64xx_device_iis0,
	&s3c64xx_device_iis1,
	&samsung_device_keypad,
	&crag6410_gpio_keydev,
	&crag6410_dm9k_device,
	&s3c64xx_device_spi0,
	&crag6410_mmgpio,
	&crag6410_lcd_powerdev,
	&crag6410_backlight_device,
388
	&speyside_device,
389
	&tobermory_device,
390
	&littlemill_device,
391
	&lowland_device,
392
	&bells_wm2200_device,
393 394
	&bells_wm5102_device,
	&bells_wm5110_device,
395
	&wallvdd_device,
396 397 398 399
};

static struct pca953x_platform_data crag6410_pca_data = {
	.gpio_base	= PCA935X_GPIO_BASE,
400
	.irq_base	= -1,
401 402
};

403 404 405 406 407 408
/* VDDARM is controlled by DVS1 connected to GPK(0) */
static struct wm831x_buckv_pdata vddarm_pdata = {
	.dvs_control_src = 1,
	.dvs_gpio = S3C64XX_GPK(0),
};

409
static struct regulator_consumer_supply vddarm_consumers[] = {
410 411 412
	REGULATOR_SUPPLY("vddarm", NULL),
};

413
static struct regulator_init_data vddarm = {
414 415 416 417 418 419 420 421 422
	.constraints = {
		.name = "VDDARM",
		.min_uV = 1000000,
		.max_uV = 1300000,
		.always_on = 1,
		.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
	},
	.num_consumer_supplies = ARRAY_SIZE(vddarm_consumers),
	.consumer_supplies = vddarm_consumers,
423
	.supply_regulator = "WALLVDD",
424
	.driver_data = &vddarm_pdata,
425 426
};

427
static struct regulator_consumer_supply vddint_consumers[] = {
428 429 430
	REGULATOR_SUPPLY("vddint", NULL),
};

431
static struct regulator_init_data vddint = {
432 433 434 435 436 437 438
	.constraints = {
		.name = "VDDINT",
		.min_uV = 1000000,
		.max_uV = 1200000,
		.always_on = 1,
		.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
	},
439 440 441
	.num_consumer_supplies = ARRAY_SIZE(vddint_consumers),
	.consumer_supplies = vddint_consumers,
	.supply_regulator = "WALLVDD",
442 443
};

444
static struct regulator_init_data vddmem = {
445 446 447 448 449 450
	.constraints = {
		.name = "VDDMEM",
		.always_on = 1,
	},
};

451
static struct regulator_init_data vddsys = {
452 453 454 455 456 457
	.constraints = {
		.name = "VDDSYS,VDDEXT,VDDPCM,VDDSS",
		.always_on = 1,
	},
};

458
static struct regulator_consumer_supply vddmmc_consumers[] = {
459 460 461 462 463
	REGULATOR_SUPPLY("vmmc", "s3c-sdhci.0"),
	REGULATOR_SUPPLY("vmmc", "s3c-sdhci.1"),
	REGULATOR_SUPPLY("vmmc", "s3c-sdhci.2"),
};

464
static struct regulator_init_data vddmmc = {
465 466 467 468 469 470
	.constraints = {
		.name = "VDDMMC,UH",
		.always_on = 1,
	},
	.num_consumer_supplies = ARRAY_SIZE(vddmmc_consumers),
	.consumer_supplies = vddmmc_consumers,
471
	.supply_regulator = "WALLVDD",
472 473
};

474
static struct regulator_init_data vddotgi = {
475 476 477 478
	.constraints = {
		.name = "VDDOTGi",
		.always_on = 1,
	},
479
	.supply_regulator = "WALLVDD",
480 481
};

482
static struct regulator_init_data vddotg = {
483 484 485 486
	.constraints = {
		.name = "VDDOTG",
		.always_on = 1,
	},
487
	.supply_regulator = "WALLVDD",
488 489
};

490
static struct regulator_init_data vddhi = {
491 492 493 494
	.constraints = {
		.name = "VDDHI",
		.always_on = 1,
	},
495
	.supply_regulator = "WALLVDD",
496 497
};

498
static struct regulator_init_data vddadc = {
499 500 501 502
	.constraints = {
		.name = "VDDADC,VDDDAC",
		.always_on = 1,
	},
503
	.supply_regulator = "WALLVDD",
504 505
};

506
static struct regulator_init_data vddmem0 = {
507 508 509 510
	.constraints = {
		.name = "VDDMEM0",
		.always_on = 1,
	},
511
	.supply_regulator = "WALLVDD",
512 513
};

514
static struct regulator_init_data vddpll = {
515 516 517 518
	.constraints = {
		.name = "VDDPLL",
		.always_on = 1,
	},
519
	.supply_regulator = "WALLVDD",
520 521
};

522
static struct regulator_init_data vddlcd = {
523 524 525 526
	.constraints = {
		.name = "VDDLCD",
		.always_on = 1,
	},
527
	.supply_regulator = "WALLVDD",
528 529
};

530
static struct regulator_init_data vddalive = {
531 532 533 534
	.constraints = {
		.name = "VDDALIVE",
		.always_on = 1,
	},
535
	.supply_regulator = "WALLVDD",
536 537
};

538
static struct wm831x_backup_pdata banff_backup_pdata = {
539 540 541 542 543
	.charger_enable = 1,
	.vlim = 2500,  /* mV */
	.ilim = 200,   /* uA */
};

544
static struct wm831x_status_pdata banff_red_led = {
545 546 547 548
	.name = "banff:red:",
	.default_src = WM831X_STATUS_MANUAL,
};

549
static struct wm831x_status_pdata banff_green_led = {
550 551 552 553
	.name = "banff:green:",
	.default_src = WM831X_STATUS_MANUAL,
};

554
static struct wm831x_touch_pdata touch_pdata = {
555
	.data_irq = S3C_EINT(26),
556
	.pd_irq = S3C_EINT(27),
557 558
};

559
static struct wm831x_pdata crag_pmic_pdata = {
560
	.wm831x_num = 1,
561
	.gpio_base = BANFF_PMIC_GPIO_BASE,
562
	.soft_shutdown = true,
563

564 565
	.backup = &banff_backup_pdata,

566
	.gpio_defaults = {
567 568
		/* GPIO5: DVS1_REQ - CMOS, DBVDD, active high */
		[4] = WM831X_GPN_DIR | WM831X_GPN_POL | WM831X_GPN_ENA | 0x8,
569 570 571 572 573 574
		/* GPIO11: Touchscreen data - CMOS, DBVDD, active high*/
		[10] = WM831X_GPN_POL | WM831X_GPN_ENA | 0x6,
		/* GPIO12: Touchscreen pen down - CMOS, DBVDD, active high*/
		[11] = WM831X_GPN_POL | WM831X_GPN_ENA | 0x7,
	},

575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602
	.dcdc = {
		&vddarm,  /* DCDC1 */
		&vddint,  /* DCDC2 */
		&vddmem,  /* DCDC3 */
	},

	.ldo = {
		&vddsys,   /* LDO1 */
		&vddmmc,   /* LDO2 */
		NULL,      /* LDO3 */
		&vddotgi,  /* LDO4 */
		&vddotg,   /* LDO5 */
		&vddhi,    /* LDO6 */
		&vddadc,   /* LDO7 */
		&vddmem0,  /* LDO8 */
		&vddpll,   /* LDO9 */
		&vddlcd,   /* LDO10 */
		&vddalive, /* LDO11 */
	},

	.status = {
		&banff_green_led,
		&banff_red_led,
	},

	.touch = &touch_pdata,
};

603
static struct i2c_board_info i2c_devs0[] = {
604 605 606 607 608 609 610 611 612 613 614 615 616 617
	{ I2C_BOARD_INFO("24c08", 0x50), },
	{ I2C_BOARD_INFO("tca6408", 0x20),
	  .platform_data = &crag6410_pca_data,
	},
	{ I2C_BOARD_INFO("wm8312", 0x34),
	  .platform_data = &crag_pmic_pdata,
	  .irq = S3C_EINT(23),
	},
};

static struct s3c2410_platform_i2c i2c0_pdata = {
	.frequency = 400000,
};

618
static struct regulator_consumer_supply pvdd_1v2_consumers[] = {
619 620
	REGULATOR_SUPPLY("DCVDD", "spi0.0"),
	REGULATOR_SUPPLY("AVDD", "spi0.0"),
621
	REGULATOR_SUPPLY("AVDD", "spi0.1"),
622 623
};

624
static struct regulator_init_data pvdd_1v2 = {
625 626
	.constraints = {
		.name = "PVDD_1V2",
627
		.valid_ops_mask = REGULATOR_CHANGE_STATUS,
628
	},
629 630 631

	.consumer_supplies = pvdd_1v2_consumers,
	.num_consumer_supplies = ARRAY_SIZE(pvdd_1v2_consumers),
632 633
};

634
static struct regulator_consumer_supply pvdd_1v8_consumers[] = {
635
	REGULATOR_SUPPLY("LDOVDD", "1-001a"),
636 637
	REGULATOR_SUPPLY("PLLVDD", "1-001a"),
	REGULATOR_SUPPLY("DBVDD", "1-001a"),
638 639 640
	REGULATOR_SUPPLY("DBVDD1", "1-001a"),
	REGULATOR_SUPPLY("DBVDD2", "1-001a"),
	REGULATOR_SUPPLY("DBVDD3", "1-001a"),
641 642 643 644
	REGULATOR_SUPPLY("CPVDD", "1-001a"),
	REGULATOR_SUPPLY("AVDD2", "1-001a"),
	REGULATOR_SUPPLY("DCVDD", "1-001a"),
	REGULATOR_SUPPLY("AVDD", "1-001a"),
645
	REGULATOR_SUPPLY("DBVDD", "spi0.0"),
646 647 648 649 650

	REGULATOR_SUPPLY("DBVDD", "1-003a"),
	REGULATOR_SUPPLY("LDOVDD", "1-003a"),
	REGULATOR_SUPPLY("CPVDD", "1-003a"),
	REGULATOR_SUPPLY("AVDD", "1-003a"),
651 652 653 654 655 656 657 658 659 660 661 662 663
	REGULATOR_SUPPLY("DBVDD1", "spi0.1"),
	REGULATOR_SUPPLY("DBVDD2", "spi0.1"),
	REGULATOR_SUPPLY("DBVDD3", "spi0.1"),
	REGULATOR_SUPPLY("LDOVDD", "spi0.1"),
	REGULATOR_SUPPLY("CPVDD", "spi0.1"),

	REGULATOR_SUPPLY("DBVDD2", "wm5102-codec"),
	REGULATOR_SUPPLY("DBVDD3", "wm5102-codec"),
	REGULATOR_SUPPLY("CPVDD", "wm5102-codec"),

	REGULATOR_SUPPLY("DBVDD2", "wm5110-codec"),
	REGULATOR_SUPPLY("DBVDD3", "wm5110-codec"),
	REGULATOR_SUPPLY("CPVDD", "wm5110-codec"),
664 665
};

666
static struct regulator_init_data pvdd_1v8 = {
667 668 669 670 671 672 673 674 675
	.constraints = {
		.name = "PVDD_1V8",
		.always_on = 1,
	},

	.consumer_supplies = pvdd_1v8_consumers,
	.num_consumer_supplies = ARRAY_SIZE(pvdd_1v8_consumers),
};

676
static struct regulator_consumer_supply pvdd_3v3_consumers[] = {
677 678 679 680
	REGULATOR_SUPPLY("MICVDD", "1-001a"),
	REGULATOR_SUPPLY("AVDD1", "1-001a"),
};

681
static struct regulator_init_data pvdd_3v3 = {
682 683 684 685 686 687 688 689 690
	.constraints = {
		.name = "PVDD_3V3",
		.always_on = 1,
	},

	.consumer_supplies = pvdd_3v3_consumers,
	.num_consumer_supplies = ARRAY_SIZE(pvdd_3v3_consumers),
};

691
static struct wm831x_pdata glenfarclas_pmic_pdata = {
692 693 694
	.wm831x_num = 2,
	.irq_base = GLENFARCLAS_PMIC_IRQ_BASE,
	.gpio_base = GLENFARCLAS_PMIC_GPIO_BASE,
695
	.soft_shutdown = true,
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712

	.gpio_defaults = {
		/* GPIO1-3: IRQ inputs, rising edge triggered, CMOS */
		[0] = WM831X_GPN_DIR | WM831X_GPN_POL | WM831X_GPN_ENA,
		[1] = WM831X_GPN_DIR | WM831X_GPN_POL | WM831X_GPN_ENA,
		[2] = WM831X_GPN_DIR | WM831X_GPN_POL | WM831X_GPN_ENA,
	},

	.dcdc = {
		&pvdd_1v2,  /* DCDC1 */
		&pvdd_1v8,  /* DCDC2 */
		&pvdd_3v3,  /* DCDC3 */
	},

	.disable_touch = true,
};

713 714 715 716 717 718 719 720 721 722
static struct wm1250_ev1_pdata wm1250_ev1_pdata = {
	.gpios = {
		[WM1250_EV1_GPIO_CLK_ENA] = S3C64XX_GPN(12),
		[WM1250_EV1_GPIO_CLK_SEL0] = S3C64XX_GPL(12),
		[WM1250_EV1_GPIO_CLK_SEL1] = S3C64XX_GPL(13),
		[WM1250_EV1_GPIO_OSR] = S3C64XX_GPL(14),
		[WM1250_EV1_GPIO_MASTER] = S3C64XX_GPL(8),
	},
};

723
static struct i2c_board_info i2c_devs1[] = {
724
	{ I2C_BOARD_INFO("wm8311", 0x34),
725 726 727
	  .irq = S3C_EINT(0),
	  .platform_data = &glenfarclas_pmic_pdata },

728
	{ I2C_BOARD_INFO("wlf-gf-module", 0x20) },
729
	{ I2C_BOARD_INFO("wlf-gf-module", 0x22) },
730 731 732 733
	{ I2C_BOARD_INFO("wlf-gf-module", 0x24) },
	{ I2C_BOARD_INFO("wlf-gf-module", 0x25) },
	{ I2C_BOARD_INFO("wlf-gf-module", 0x26) },

734 735
	{ I2C_BOARD_INFO("wm1250-ev1", 0x27),
	  .platform_data = &wm1250_ev1_pdata },
736 737
};

738 739 740
static struct s3c2410_platform_i2c i2c1_pdata = {
	.frequency = 400000,
	.bus_num = 1,
741 742 743 744 745 746 747
};

static void __init crag6410_map_io(void)
{
	s3c64xx_init_io(NULL, 0);
	s3c24xx_init_clocks(12000000);
	s3c24xx_init_uarts(crag6410_uartcfgs, ARRAY_SIZE(crag6410_uartcfgs));
748
	samsung_set_timer_source(SAMSUNG_PWM3, SAMSUNG_PWM4);
749 750 751 752 753 754 755

	/* LCD type and Bypass set by bootloader */
}

static struct s3c_sdhci_platdata crag6410_hsmmc2_pdata = {
	.max_width		= 4,
	.cd_type		= S3C_SDHCI_CD_PERMANENT,
756
	.host_caps		= MMC_CAP_POWER_OFF_CARD,
757 758 759 760 761 762 763 764 765 766 767 768 769 770 771
};

static void crag6410_cfg_sdhci0(struct platform_device *dev, int width)
{
	/* Set all the necessary GPG pins to special-function 2 */
	s3c_gpio_cfgrange_nopull(S3C64XX_GPG(0), 2 + width, S3C_GPIO_SFN(2));

	/* force card-detected for prototype 0 */
	s3c_gpio_setpull(S3C64XX_GPG(6), S3C_GPIO_PULL_DOWN);
}

static struct s3c_sdhci_platdata crag6410_hsmmc0_pdata = {
	.max_width		= 4,
	.cd_type		= S3C_SDHCI_CD_INTERNAL,
	.cfg_gpio		= crag6410_cfg_sdhci0,
772
	.host_caps		= MMC_CAP_POWER_OFF_CARD,
773 774
};

775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820
static const struct gpio_led gpio_leds[] = {
	{
		.name = "d13:green:",
		.gpio = MMGPIO_GPIO_BASE + 0,
		.default_state = LEDS_GPIO_DEFSTATE_ON,
	},
	{
		.name = "d14:green:",
		.gpio = MMGPIO_GPIO_BASE + 1,
		.default_state = LEDS_GPIO_DEFSTATE_ON,
	},
	{
		.name = "d15:green:",
		.gpio = MMGPIO_GPIO_BASE + 2,
		.default_state = LEDS_GPIO_DEFSTATE_ON,
	},
	{
		.name = "d16:green:",
		.gpio = MMGPIO_GPIO_BASE + 3,
		.default_state = LEDS_GPIO_DEFSTATE_ON,
	},
	{
		.name = "d17:green:",
		.gpio = MMGPIO_GPIO_BASE + 4,
		.default_state = LEDS_GPIO_DEFSTATE_ON,
	},
	{
		.name = "d18:green:",
		.gpio = MMGPIO_GPIO_BASE + 5,
		.default_state = LEDS_GPIO_DEFSTATE_ON,
	},
	{
		.name = "d19:green:",
		.gpio = MMGPIO_GPIO_BASE + 6,
		.default_state = LEDS_GPIO_DEFSTATE_ON,
	},
	{
		.name = "d20:green:",
		.gpio = MMGPIO_GPIO_BASE + 7,
		.default_state = LEDS_GPIO_DEFSTATE_ON,
	},
};

static const struct gpio_led_platform_data gpio_leds_pdata = {
	.leds = gpio_leds,
	.num_leds = ARRAY_SIZE(gpio_leds),
821 822
};

823 824
static struct s3c_hsotg_plat crag6410_hsotg_pdata;

825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846
static void __init crag6410_machine_init(void)
{
	/* Open drain IRQs need pullups */
	s3c_gpio_setpull(S3C64XX_GPM(0), S3C_GPIO_PULL_UP);
	s3c_gpio_setpull(S3C64XX_GPN(0), S3C_GPIO_PULL_UP);

	gpio_request(S3C64XX_GPB(0), "LCD power");
	gpio_direction_output(S3C64XX_GPB(0), 0);

	gpio_request(S3C64XX_GPF(14), "LCD PWM");
	gpio_direction_output(S3C64XX_GPF(14), 0);  /* turn off */

	gpio_request(S3C64XX_GPB(1), "SD power");
	gpio_direction_output(S3C64XX_GPB(1), 0);

	gpio_request(S3C64XX_GPF(10), "nRESETSEL");
	gpio_direction_output(S3C64XX_GPF(10), 1);

	s3c_sdhci0_set_platdata(&crag6410_hsmmc0_pdata);
	s3c_sdhci2_set_platdata(&crag6410_hsmmc2_pdata);

	s3c_i2c0_set_platdata(&i2c0_pdata);
847
	s3c_i2c1_set_platdata(&i2c1_pdata);
848
	s3c_fb_set_platdata(&crag6410_lcd_pdata);
849
	s3c_hsotg_set_platdata(&crag6410_hsotg_pdata);
850 851 852 853 854

	i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));
	i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));

	samsung_keypad_set_platdata(&crag6410_keypad_data);
855
	s3c64xx_spi0_set_platdata(NULL, 0, 2);
856 857 858

	platform_add_devices(crag6410_devices, ARRAY_SIZE(crag6410_devices));

859 860
	gpio_led_register_device(-1, &gpio_leds_pdata);

861 862
	regulator_has_full_constraints();

863
	s3c64xx_pm_init();
864 865 866 867
}

MACHINE_START(WLF_CRAGG_6410, "Wolfson Cragganmore 6410")
	/* Maintainer: Mark Brown <broonie@opensource.wolfsonmicro.com> */
868
	.atag_offset	= 0x100,
869 870 871
	.init_irq	= s3c6410_init_irq,
	.map_io		= crag6410_map_io,
	.init_machine	= crag6410_machine_init,
872
	.init_late	= s3c64xx_init_late,
873
	.init_time	= samsung_timer_init,
874
	.restart	= s3c64xx_restart,
875
MACHINE_END