1/* linux/arch/arm/plat-samsung/devs.c 2 * 3 * Copyright (c) 2011 Samsung Electronics Co., Ltd. 4 * http://www.samsung.com 5 * 6 * Base SAMSUNG platform device definitions 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11*/ 12 13#include <linux/amba/pl330.h> 14#include <linux/kernel.h> 15#include <linux/types.h> 16#include <linux/interrupt.h> 17#include <linux/list.h> 18#include <linux/timer.h> 19#include <linux/init.h> 20#include <linux/serial_core.h> 21#include <linux/serial_s3c.h> 22#include <linux/platform_device.h> 23#include <linux/io.h> 24#include <linux/slab.h> 25#include <linux/string.h> 26#include <linux/dma-mapping.h> 27#include <linux/fb.h> 28#include <linux/gfp.h> 29#include <linux/mtd/mtd.h> 30#include <linux/mtd/onenand.h> 31#include <linux/mtd/partitions.h> 32#include <linux/mmc/host.h> 33#include <linux/ioport.h> 34#include <linux/sizes.h> 35#include <linux/platform_data/s3c-hsudc.h> 36#include <linux/platform_data/s3c-hsotg.h> 37#include <linux/platform_data/dma-s3c24xx.h> 38 39#include <media/s5p_hdmi.h> 40 41#include <asm/irq.h> 42#include <asm/mach/arch.h> 43#include <asm/mach/map.h> 44#include <asm/mach/irq.h> 45 46#include <mach/dma.h> 47#include <mach/irqs.h> 48#include <mach/map.h> 49 50#include <plat/cpu.h> 51#include <plat/devs.h> 52#include <plat/adc.h> 53#include <linux/platform_data/ata-samsung_cf.h> 54#include <plat/fb.h> 55#include <plat/fb-s3c2410.h> 56#include <linux/platform_data/hwmon-s3c.h> 57#include <linux/platform_data/i2c-s3c2410.h> 58#include <plat/keypad.h> 59#include <linux/platform_data/mmc-s3cmci.h> 60#include <linux/platform_data/mtd-nand-s3c2410.h> 61#include <plat/pwm-core.h> 62#include <plat/sdhci.h> 63#include <linux/platform_data/touchscreen-s3c2410.h> 64#include <linux/platform_data/usb-s3c2410_udc.h> 65#include <linux/platform_data/usb-ohci-s3c2410.h> 66#include <plat/usb-phy.h> 67#include <plat/regs-spi.h> 68#include <linux/platform_data/asoc-s3c.h> 69#include <linux/platform_data/spi-s3c64xx.h> 70 71static u64 samsung_device_dma_mask = DMA_BIT_MASK(32); 72 73/* AC97 */ 74#ifdef CONFIG_CPU_S3C2440 75static struct resource s3c_ac97_resource[] = { 76 [0] = DEFINE_RES_MEM(S3C2440_PA_AC97, S3C2440_SZ_AC97), 77 [1] = DEFINE_RES_IRQ(IRQ_S3C244X_AC97), 78}; 79 80static struct s3c_audio_pdata s3c_ac97_pdata = { 81 .dma_playback = (void *)DMACH_PCM_OUT, 82 .dma_capture = (void *)DMACH_PCM_IN, 83 .dma_capture_mic = (void *)DMACH_MIC_IN, 84}; 85 86struct platform_device s3c_device_ac97 = { 87 .name = "samsung-ac97", 88 .id = -1, 89 .num_resources = ARRAY_SIZE(s3c_ac97_resource), 90 .resource = s3c_ac97_resource, 91 .dev = { 92 .dma_mask = &samsung_device_dma_mask, 93 .coherent_dma_mask = DMA_BIT_MASK(32), 94 .platform_data = &s3c_ac97_pdata, 95 } 96}; 97#endif /* CONFIG_CPU_S3C2440 */ 98 99/* ADC */ 100 101#ifdef CONFIG_PLAT_S3C24XX 102static struct resource s3c_adc_resource[] = { 103 [0] = DEFINE_RES_MEM(S3C24XX_PA_ADC, S3C24XX_SZ_ADC), 104 [1] = DEFINE_RES_IRQ(IRQ_TC), 105 [2] = DEFINE_RES_IRQ(IRQ_ADC), 106}; 107 108struct platform_device s3c_device_adc = { 109 .name = "s3c24xx-adc", 110 .id = -1, 111 .num_resources = ARRAY_SIZE(s3c_adc_resource), 112 .resource = s3c_adc_resource, 113}; 114#endif /* CONFIG_PLAT_S3C24XX */ 115 116#if defined(CONFIG_SAMSUNG_DEV_ADC) 117static struct resource s3c_adc_resource[] = { 118 [0] = DEFINE_RES_MEM(SAMSUNG_PA_ADC, SZ_256), 119 [1] = DEFINE_RES_IRQ(IRQ_TC), 120 [2] = DEFINE_RES_IRQ(IRQ_ADC), 121}; 122 123struct platform_device s3c_device_adc = { 124 .name = "samsung-adc", 125 .id = -1, 126 .num_resources = ARRAY_SIZE(s3c_adc_resource), 127 .resource = s3c_adc_resource, 128}; 129#endif /* CONFIG_SAMSUNG_DEV_ADC */ 130 131/* Camif Controller */ 132 133#ifdef CONFIG_CPU_S3C2440 134static struct resource s3c_camif_resource[] = { 135 [0] = DEFINE_RES_MEM(S3C2440_PA_CAMIF, S3C2440_SZ_CAMIF), 136 [1] = DEFINE_RES_IRQ(IRQ_S3C2440_CAM_C), 137 [2] = DEFINE_RES_IRQ(IRQ_S3C2440_CAM_P), 138}; 139 140struct platform_device s3c_device_camif = { 141 .name = "s3c2440-camif", 142 .id = -1, 143 .num_resources = ARRAY_SIZE(s3c_camif_resource), 144 .resource = s3c_camif_resource, 145 .dev = { 146 .dma_mask = &samsung_device_dma_mask, 147 .coherent_dma_mask = DMA_BIT_MASK(32), 148 } 149}; 150#endif /* CONFIG_CPU_S3C2440 */ 151 152/* FB */ 153 154#ifdef CONFIG_S3C_DEV_FB 155static struct resource s3c_fb_resource[] = { 156 [0] = DEFINE_RES_MEM(S3C_PA_FB, SZ_16K), 157 [1] = DEFINE_RES_IRQ(IRQ_LCD_VSYNC), 158 [2] = DEFINE_RES_IRQ(IRQ_LCD_FIFO), 159 [3] = DEFINE_RES_IRQ(IRQ_LCD_SYSTEM), 160}; 161 162struct platform_device s3c_device_fb = { 163 .name = "s3c-fb", 164 .id = -1, 165 .num_resources = ARRAY_SIZE(s3c_fb_resource), 166 .resource = s3c_fb_resource, 167 .dev = { 168 .dma_mask = &samsung_device_dma_mask, 169 .coherent_dma_mask = DMA_BIT_MASK(32), 170 }, 171}; 172 173void __init s3c_fb_set_platdata(struct s3c_fb_platdata *pd) 174{ 175 s3c_set_platdata(pd, sizeof(struct s3c_fb_platdata), 176 &s3c_device_fb); 177} 178#endif /* CONFIG_S3C_DEV_FB */ 179 180/* HWMON */ 181 182#ifdef CONFIG_S3C_DEV_HWMON 183struct platform_device s3c_device_hwmon = { 184 .name = "s3c-hwmon", 185 .id = -1, 186 .dev.parent = &s3c_device_adc.dev, 187}; 188 189void __init s3c_hwmon_set_platdata(struct s3c_hwmon_pdata *pd) 190{ 191 s3c_set_platdata(pd, sizeof(struct s3c_hwmon_pdata), 192 &s3c_device_hwmon); 193} 194#endif /* CONFIG_S3C_DEV_HWMON */ 195 196/* HSMMC */ 197 198#ifdef CONFIG_S3C_DEV_HSMMC 199static struct resource s3c_hsmmc_resource[] = { 200 [0] = DEFINE_RES_MEM(S3C_PA_HSMMC0, SZ_4K), 201 [1] = DEFINE_RES_IRQ(IRQ_HSMMC0), 202}; 203 204struct s3c_sdhci_platdata s3c_hsmmc0_def_platdata = { 205 .max_width = 4, 206 .host_caps = (MMC_CAP_4_BIT_DATA | 207 MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED), 208}; 209 210struct platform_device s3c_device_hsmmc0 = { 211 .name = "s3c-sdhci", 212 .id = 0, 213 .num_resources = ARRAY_SIZE(s3c_hsmmc_resource), 214 .resource = s3c_hsmmc_resource, 215 .dev = { 216 .dma_mask = &samsung_device_dma_mask, 217 .coherent_dma_mask = DMA_BIT_MASK(32), 218 .platform_data = &s3c_hsmmc0_def_platdata, 219 }, 220}; 221 222void s3c_sdhci0_set_platdata(struct s3c_sdhci_platdata *pd) 223{ 224 s3c_sdhci_set_platdata(pd, &s3c_hsmmc0_def_platdata); 225} 226#endif /* CONFIG_S3C_DEV_HSMMC */ 227 228#ifdef CONFIG_S3C_DEV_HSMMC1 229static struct resource s3c_hsmmc1_resource[] = { 230 [0] = DEFINE_RES_MEM(S3C_PA_HSMMC1, SZ_4K), 231 [1] = DEFINE_RES_IRQ(IRQ_HSMMC1), 232}; 233 234struct s3c_sdhci_platdata s3c_hsmmc1_def_platdata = { 235 .max_width = 4, 236 .host_caps = (MMC_CAP_4_BIT_DATA | 237 MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED), 238}; 239 240struct platform_device s3c_device_hsmmc1 = { 241 .name = "s3c-sdhci", 242 .id = 1, 243 .num_resources = ARRAY_SIZE(s3c_hsmmc1_resource), 244 .resource = s3c_hsmmc1_resource, 245 .dev = { 246 .dma_mask = &samsung_device_dma_mask, 247 .coherent_dma_mask = DMA_BIT_MASK(32), 248 .platform_data = &s3c_hsmmc1_def_platdata, 249 }, 250}; 251 252void s3c_sdhci1_set_platdata(struct s3c_sdhci_platdata *pd) 253{ 254 s3c_sdhci_set_platdata(pd, &s3c_hsmmc1_def_platdata); 255} 256#endif /* CONFIG_S3C_DEV_HSMMC1 */ 257 258/* HSMMC2 */ 259 260#ifdef CONFIG_S3C_DEV_HSMMC2 261static struct resource s3c_hsmmc2_resource[] = { 262 [0] = DEFINE_RES_MEM(S3C_PA_HSMMC2, SZ_4K), 263 [1] = DEFINE_RES_IRQ(IRQ_HSMMC2), 264}; 265 266struct s3c_sdhci_platdata s3c_hsmmc2_def_platdata = { 267 .max_width = 4, 268 .host_caps = (MMC_CAP_4_BIT_DATA | 269 MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED), 270}; 271 272struct platform_device s3c_device_hsmmc2 = { 273 .name = "s3c-sdhci", 274 .id = 2, 275 .num_resources = ARRAY_SIZE(s3c_hsmmc2_resource), 276 .resource = s3c_hsmmc2_resource, 277 .dev = { 278 .dma_mask = &samsung_device_dma_mask, 279 .coherent_dma_mask = DMA_BIT_MASK(32), 280 .platform_data = &s3c_hsmmc2_def_platdata, 281 }, 282}; 283 284void s3c_sdhci2_set_platdata(struct s3c_sdhci_platdata *pd) 285{ 286 s3c_sdhci_set_platdata(pd, &s3c_hsmmc2_def_platdata); 287} 288#endif /* CONFIG_S3C_DEV_HSMMC2 */ 289 290#ifdef CONFIG_S3C_DEV_HSMMC3 291static struct resource s3c_hsmmc3_resource[] = { 292 [0] = DEFINE_RES_MEM(S3C_PA_HSMMC3, SZ_4K), 293 [1] = DEFINE_RES_IRQ(IRQ_HSMMC3), 294}; 295 296struct s3c_sdhci_platdata s3c_hsmmc3_def_platdata = { 297 .max_width = 4, 298 .host_caps = (MMC_CAP_4_BIT_DATA | 299 MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED), 300}; 301 302struct platform_device s3c_device_hsmmc3 = { 303 .name = "s3c-sdhci", 304 .id = 3, 305 .num_resources = ARRAY_SIZE(s3c_hsmmc3_resource), 306 .resource = s3c_hsmmc3_resource, 307 .dev = { 308 .dma_mask = &samsung_device_dma_mask, 309 .coherent_dma_mask = DMA_BIT_MASK(32), 310 .platform_data = &s3c_hsmmc3_def_platdata, 311 }, 312}; 313 314void s3c_sdhci3_set_platdata(struct s3c_sdhci_platdata *pd) 315{ 316 s3c_sdhci_set_platdata(pd, &s3c_hsmmc3_def_platdata); 317} 318#endif /* CONFIG_S3C_DEV_HSMMC3 */ 319 320/* I2C */ 321 322static struct resource s3c_i2c0_resource[] = { 323 [0] = DEFINE_RES_MEM(S3C_PA_IIC, SZ_4K), 324 [1] = DEFINE_RES_IRQ(IRQ_IIC), 325}; 326 327struct platform_device s3c_device_i2c0 = { 328 .name = "s3c2410-i2c", 329 .id = 0, 330 .num_resources = ARRAY_SIZE(s3c_i2c0_resource), 331 .resource = s3c_i2c0_resource, 332}; 333 334struct s3c2410_platform_i2c default_i2c_data __initdata = { 335 .flags = 0, 336 .slave_addr = 0x10, 337 .frequency = 100*1000, 338 .sda_delay = 100, 339}; 340 341void __init s3c_i2c0_set_platdata(struct s3c2410_platform_i2c *pd) 342{ 343 struct s3c2410_platform_i2c *npd; 344 345 if (!pd) { 346 pd = &default_i2c_data; 347 pd->bus_num = 0; 348 } 349 350 npd = s3c_set_platdata(pd, sizeof(struct s3c2410_platform_i2c), 351 &s3c_device_i2c0); 352 353 if (!npd->cfg_gpio) 354 npd->cfg_gpio = s3c_i2c0_cfg_gpio; 355} 356 357#ifdef CONFIG_S3C_DEV_I2C1 358static struct resource s3c_i2c1_resource[] = { 359 [0] = DEFINE_RES_MEM(S3C_PA_IIC1, SZ_4K), 360 [1] = DEFINE_RES_IRQ(IRQ_IIC1), 361}; 362 363struct platform_device s3c_device_i2c1 = { 364 .name = "s3c2410-i2c", 365 .id = 1, 366 .num_resources = ARRAY_SIZE(s3c_i2c1_resource), 367 .resource = s3c_i2c1_resource, 368}; 369 370void __init s3c_i2c1_set_platdata(struct s3c2410_platform_i2c *pd) 371{ 372 struct s3c2410_platform_i2c *npd; 373 374 if (!pd) { 375 pd = &default_i2c_data; 376 pd->bus_num = 1; 377 } 378 379 npd = s3c_set_platdata(pd, sizeof(struct s3c2410_platform_i2c), 380 &s3c_device_i2c1); 381 382 if (!npd->cfg_gpio) 383 npd->cfg_gpio = s3c_i2c1_cfg_gpio; 384} 385#endif /* CONFIG_S3C_DEV_I2C1 */ 386 387#ifdef CONFIG_S3C_DEV_I2C2 388static struct resource s3c_i2c2_resource[] = { 389 [0] = DEFINE_RES_MEM(S3C_PA_IIC2, SZ_4K), 390 [1] = DEFINE_RES_IRQ(IRQ_IIC2), 391}; 392 393struct platform_device s3c_device_i2c2 = { 394 .name = "s3c2410-i2c", 395 .id = 2, 396 .num_resources = ARRAY_SIZE(s3c_i2c2_resource), 397 .resource = s3c_i2c2_resource, 398}; 399 400void __init s3c_i2c2_set_platdata(struct s3c2410_platform_i2c *pd) 401{ 402 struct s3c2410_platform_i2c *npd; 403 404 if (!pd) { 405 pd = &default_i2c_data; 406 pd->bus_num = 2; 407 } 408 409 npd = s3c_set_platdata(pd, sizeof(struct s3c2410_platform_i2c), 410 &s3c_device_i2c2); 411 412 if (!npd->cfg_gpio) 413 npd->cfg_gpio = s3c_i2c2_cfg_gpio; 414} 415#endif /* CONFIG_S3C_DEV_I2C2 */ 416 417#ifdef CONFIG_S3C_DEV_I2C3 418static struct resource s3c_i2c3_resource[] = { 419 [0] = DEFINE_RES_MEM(S3C_PA_IIC3, SZ_4K), 420 [1] = DEFINE_RES_IRQ(IRQ_IIC3), 421}; 422 423struct platform_device s3c_device_i2c3 = { 424 .name = "s3c2440-i2c", 425 .id = 3, 426 .num_resources = ARRAY_SIZE(s3c_i2c3_resource), 427 .resource = s3c_i2c3_resource, 428}; 429 430void __init s3c_i2c3_set_platdata(struct s3c2410_platform_i2c *pd) 431{ 432 struct s3c2410_platform_i2c *npd; 433 434 if (!pd) { 435 pd = &default_i2c_data; 436 pd->bus_num = 3; 437 } 438 439 npd = s3c_set_platdata(pd, sizeof(struct s3c2410_platform_i2c), 440 &s3c_device_i2c3); 441 442 if (!npd->cfg_gpio) 443 npd->cfg_gpio = s3c_i2c3_cfg_gpio; 444} 445#endif /*CONFIG_S3C_DEV_I2C3 */ 446 447#ifdef CONFIG_S3C_DEV_I2C4 448static struct resource s3c_i2c4_resource[] = { 449 [0] = DEFINE_RES_MEM(S3C_PA_IIC4, SZ_4K), 450 [1] = DEFINE_RES_IRQ(IRQ_IIC4), 451}; 452 453struct platform_device s3c_device_i2c4 = { 454 .name = "s3c2440-i2c", 455 .id = 4, 456 .num_resources = ARRAY_SIZE(s3c_i2c4_resource), 457 .resource = s3c_i2c4_resource, 458}; 459 460void __init s3c_i2c4_set_platdata(struct s3c2410_platform_i2c *pd) 461{ 462 struct s3c2410_platform_i2c *npd; 463 464 if (!pd) { 465 pd = &default_i2c_data; 466 pd->bus_num = 4; 467 } 468 469 npd = s3c_set_platdata(pd, sizeof(struct s3c2410_platform_i2c), 470 &s3c_device_i2c4); 471 472 if (!npd->cfg_gpio) 473 npd->cfg_gpio = s3c_i2c4_cfg_gpio; 474} 475#endif /*CONFIG_S3C_DEV_I2C4 */ 476 477#ifdef CONFIG_S3C_DEV_I2C5 478static struct resource s3c_i2c5_resource[] = { 479 [0] = DEFINE_RES_MEM(S3C_PA_IIC5, SZ_4K), 480 [1] = DEFINE_RES_IRQ(IRQ_IIC5), 481}; 482 483struct platform_device s3c_device_i2c5 = { 484 .name = "s3c2440-i2c", 485 .id = 5, 486 .num_resources = ARRAY_SIZE(s3c_i2c5_resource), 487 .resource = s3c_i2c5_resource, 488}; 489 490void __init s3c_i2c5_set_platdata(struct s3c2410_platform_i2c *pd) 491{ 492 struct s3c2410_platform_i2c *npd; 493 494 if (!pd) { 495 pd = &default_i2c_data; 496 pd->bus_num = 5; 497 } 498 499 npd = s3c_set_platdata(pd, sizeof(struct s3c2410_platform_i2c), 500 &s3c_device_i2c5); 501 502 if (!npd->cfg_gpio) 503 npd->cfg_gpio = s3c_i2c5_cfg_gpio; 504} 505#endif /*CONFIG_S3C_DEV_I2C5 */ 506 507#ifdef CONFIG_S3C_DEV_I2C6 508static struct resource s3c_i2c6_resource[] = { 509 [0] = DEFINE_RES_MEM(S3C_PA_IIC6, SZ_4K), 510 [1] = DEFINE_RES_IRQ(IRQ_IIC6), 511}; 512 513struct platform_device s3c_device_i2c6 = { 514 .name = "s3c2440-i2c", 515 .id = 6, 516 .num_resources = ARRAY_SIZE(s3c_i2c6_resource), 517 .resource = s3c_i2c6_resource, 518}; 519 520void __init s3c_i2c6_set_platdata(struct s3c2410_platform_i2c *pd) 521{ 522 struct s3c2410_platform_i2c *npd; 523 524 if (!pd) { 525 pd = &default_i2c_data; 526 pd->bus_num = 6; 527 } 528 529 npd = s3c_set_platdata(pd, sizeof(struct s3c2410_platform_i2c), 530 &s3c_device_i2c6); 531 532 if (!npd->cfg_gpio) 533 npd->cfg_gpio = s3c_i2c6_cfg_gpio; 534} 535#endif /* CONFIG_S3C_DEV_I2C6 */ 536 537#ifdef CONFIG_S3C_DEV_I2C7 538static struct resource s3c_i2c7_resource[] = { 539 [0] = DEFINE_RES_MEM(S3C_PA_IIC7, SZ_4K), 540 [1] = DEFINE_RES_IRQ(IRQ_IIC7), 541}; 542 543struct platform_device s3c_device_i2c7 = { 544 .name = "s3c2440-i2c", 545 .id = 7, 546 .num_resources = ARRAY_SIZE(s3c_i2c7_resource), 547 .resource = s3c_i2c7_resource, 548}; 549 550void __init s3c_i2c7_set_platdata(struct s3c2410_platform_i2c *pd) 551{ 552 struct s3c2410_platform_i2c *npd; 553 554 if (!pd) { 555 pd = &default_i2c_data; 556 pd->bus_num = 7; 557 } 558 559 npd = s3c_set_platdata(pd, sizeof(struct s3c2410_platform_i2c), 560 &s3c_device_i2c7); 561 562 if (!npd->cfg_gpio) 563 npd->cfg_gpio = s3c_i2c7_cfg_gpio; 564} 565#endif /* CONFIG_S3C_DEV_I2C7 */ 566 567/* I2S */ 568 569#ifdef CONFIG_PLAT_S3C24XX 570static struct resource s3c_iis_resource[] = { 571 [0] = DEFINE_RES_MEM(S3C24XX_PA_IIS, S3C24XX_SZ_IIS), 572}; 573 574struct platform_device s3c_device_iis = { 575 .name = "s3c24xx-iis", 576 .id = -1, 577 .num_resources = ARRAY_SIZE(s3c_iis_resource), 578 .resource = s3c_iis_resource, 579 .dev = { 580 .dma_mask = &samsung_device_dma_mask, 581 .coherent_dma_mask = DMA_BIT_MASK(32), 582 } 583}; 584#endif /* CONFIG_PLAT_S3C24XX */ 585 586/* IDE CFCON */ 587 588#ifdef CONFIG_SAMSUNG_DEV_IDE 589static struct resource s3c_cfcon_resource[] = { 590 [0] = DEFINE_RES_MEM(SAMSUNG_PA_CFCON, SZ_16K), 591 [1] = DEFINE_RES_IRQ(IRQ_CFCON), 592}; 593 594struct platform_device s3c_device_cfcon = { 595 .id = 0, 596 .num_resources = ARRAY_SIZE(s3c_cfcon_resource), 597 .resource = s3c_cfcon_resource, 598}; 599 600void __init s3c_ide_set_platdata(struct s3c_ide_platdata *pdata) 601{ 602 s3c_set_platdata(pdata, sizeof(struct s3c_ide_platdata), 603 &s3c_device_cfcon); 604} 605#endif /* CONFIG_SAMSUNG_DEV_IDE */ 606 607/* KEYPAD */ 608 609#ifdef CONFIG_SAMSUNG_DEV_KEYPAD 610static struct resource samsung_keypad_resources[] = { 611 [0] = DEFINE_RES_MEM(SAMSUNG_PA_KEYPAD, SZ_32), 612 [1] = DEFINE_RES_IRQ(IRQ_KEYPAD), 613}; 614 615struct platform_device samsung_device_keypad = { 616 .name = "samsung-keypad", 617 .id = -1, 618 .num_resources = ARRAY_SIZE(samsung_keypad_resources), 619 .resource = samsung_keypad_resources, 620}; 621 622void __init samsung_keypad_set_platdata(struct samsung_keypad_platdata *pd) 623{ 624 struct samsung_keypad_platdata *npd; 625 626 npd = s3c_set_platdata(pd, sizeof(struct samsung_keypad_platdata), 627 &samsung_device_keypad); 628 629 if (!npd->cfg_gpio) 630 npd->cfg_gpio = samsung_keypad_cfg_gpio; 631} 632#endif /* CONFIG_SAMSUNG_DEV_KEYPAD */ 633 634/* LCD Controller */ 635 636#ifdef CONFIG_PLAT_S3C24XX 637static struct resource s3c_lcd_resource[] = { 638 [0] = DEFINE_RES_MEM(S3C24XX_PA_LCD, S3C24XX_SZ_LCD), 639 [1] = DEFINE_RES_IRQ(IRQ_LCD), 640}; 641 642struct platform_device s3c_device_lcd = { 643 .name = "s3c2410-lcd", 644 .id = -1, 645 .num_resources = ARRAY_SIZE(s3c_lcd_resource), 646 .resource = s3c_lcd_resource, 647 .dev = { 648 .dma_mask = &samsung_device_dma_mask, 649 .coherent_dma_mask = DMA_BIT_MASK(32), 650 } 651}; 652 653void __init s3c24xx_fb_set_platdata(struct s3c2410fb_mach_info *pd) 654{ 655 struct s3c2410fb_mach_info *npd; 656 657 npd = s3c_set_platdata(pd, sizeof(*npd), &s3c_device_lcd); 658 if (npd) { 659 npd->displays = kmemdup(pd->displays, 660 sizeof(struct s3c2410fb_display) * npd->num_displays, 661 GFP_KERNEL); 662 if (!npd->displays) 663 printk(KERN_ERR "no memory for LCD display data\n"); 664 } else { 665 printk(KERN_ERR "no memory for LCD platform data\n"); 666 } 667} 668#endif /* CONFIG_PLAT_S3C24XX */ 669 670/* NAND */ 671 672#ifdef CONFIG_S3C_DEV_NAND 673static struct resource s3c_nand_resource[] = { 674 [0] = DEFINE_RES_MEM(S3C_PA_NAND, SZ_1M), 675}; 676 677struct platform_device s3c_device_nand = { 678 .name = "s3c2410-nand", 679 .id = -1, 680 .num_resources = ARRAY_SIZE(s3c_nand_resource), 681 .resource = s3c_nand_resource, 682}; 683 684/* 685 * s3c_nand_copy_set() - copy nand set data 686 * @set: The new structure, directly copied from the old. 687 * 688 * Copy all the fields from the NAND set field from what is probably __initdata 689 * to new kernel memory. The code returns 0 if the copy happened correctly or 690 * an error code for the calling function to display. 691 * 692 * Note, we currently do not try and look to see if we've already copied the 693 * data in a previous set. 694 */ 695static int __init s3c_nand_copy_set(struct s3c2410_nand_set *set) 696{ 697 void *ptr; 698 int size; 699 700 size = sizeof(struct mtd_partition) * set->nr_partitions; 701 if (size) { 702 ptr = kmemdup(set->partitions, size, GFP_KERNEL); 703 set->partitions = ptr; 704 705 if (!ptr) 706 return -ENOMEM; 707 } 708 709 if (set->nr_map && set->nr_chips) { 710 size = sizeof(int) * set->nr_chips; 711 ptr = kmemdup(set->nr_map, size, GFP_KERNEL); 712 set->nr_map = ptr; 713 714 if (!ptr) 715 return -ENOMEM; 716 } 717 718 if (set->ecc_layout) { 719 ptr = kmemdup(set->ecc_layout, 720 sizeof(struct nand_ecclayout), GFP_KERNEL); 721 set->ecc_layout = ptr; 722 723 if (!ptr) 724 return -ENOMEM; 725 } 726 727 return 0; 728} 729 730void __init s3c_nand_set_platdata(struct s3c2410_platform_nand *nand) 731{ 732 struct s3c2410_platform_nand *npd; 733 int size; 734 int ret; 735 736 /* note, if we get a failure in allocation, we simply drop out of the 737 * function. If there is so little memory available at initialisation 738 * time then there is little chance the system is going to run. 739 */ 740 741 npd = s3c_set_platdata(nand, sizeof(struct s3c2410_platform_nand), 742 &s3c_device_nand); 743 if (!npd) 744 return; 745 746 /* now see if we need to copy any of the nand set data */ 747 748 size = sizeof(struct s3c2410_nand_set) * npd->nr_sets; 749 if (size) { 750 struct s3c2410_nand_set *from = npd->sets; 751 struct s3c2410_nand_set *to; 752 int i; 753 754 to = kmemdup(from, size, GFP_KERNEL); 755 npd->sets = to; /* set, even if we failed */ 756 757 if (!to) { 758 printk(KERN_ERR "%s: no memory for sets\n", __func__); 759 return; 760 } 761 762 for (i = 0; i < npd->nr_sets; i++) { 763 ret = s3c_nand_copy_set(to); 764 if (ret) { 765 printk(KERN_ERR "%s: failed to copy set %d\n", 766 __func__, i); 767 return; 768 } 769 to++; 770 } 771 } 772} 773#endif /* CONFIG_S3C_DEV_NAND */ 774 775/* ONENAND */ 776 777#ifdef CONFIG_S3C_DEV_ONENAND 778static struct resource s3c_onenand_resources[] = { 779 [0] = DEFINE_RES_MEM(S3C_PA_ONENAND, SZ_1K), 780 [1] = DEFINE_RES_MEM(S3C_PA_ONENAND_BUF, S3C_SZ_ONENAND_BUF), 781 [2] = DEFINE_RES_IRQ(IRQ_ONENAND), 782}; 783 784struct platform_device s3c_device_onenand = { 785 .name = "samsung-onenand", 786 .id = 0, 787 .num_resources = ARRAY_SIZE(s3c_onenand_resources), 788 .resource = s3c_onenand_resources, 789}; 790#endif /* CONFIG_S3C_DEV_ONENAND */ 791 792#ifdef CONFIG_S3C64XX_DEV_ONENAND1 793static struct resource s3c64xx_onenand1_resources[] = { 794 [0] = DEFINE_RES_MEM(S3C64XX_PA_ONENAND1, SZ_1K), 795 [1] = DEFINE_RES_MEM(S3C64XX_PA_ONENAND1_BUF, S3C64XX_SZ_ONENAND1_BUF), 796 [2] = DEFINE_RES_IRQ(IRQ_ONENAND1), 797}; 798 799struct platform_device s3c64xx_device_onenand1 = { 800 .name = "samsung-onenand", 801 .id = 1, 802 .num_resources = ARRAY_SIZE(s3c64xx_onenand1_resources), 803 .resource = s3c64xx_onenand1_resources, 804}; 805 806void __init s3c64xx_onenand1_set_platdata(struct onenand_platform_data *pdata) 807{ 808 s3c_set_platdata(pdata, sizeof(struct onenand_platform_data), 809 &s3c64xx_device_onenand1); 810} 811#endif /* CONFIG_S3C64XX_DEV_ONENAND1 */ 812 813/* PWM Timer */ 814 815#ifdef CONFIG_SAMSUNG_DEV_PWM 816static struct resource samsung_pwm_resource[] = { 817 DEFINE_RES_MEM(SAMSUNG_PA_TIMER, SZ_4K), 818}; 819 820struct platform_device samsung_device_pwm = { 821 .name = "samsung-pwm", 822 .id = -1, 823 .num_resources = ARRAY_SIZE(samsung_pwm_resource), 824 .resource = samsung_pwm_resource, 825}; 826 827void __init samsung_pwm_set_platdata(struct samsung_pwm_variant *pd) 828{ 829 samsung_device_pwm.dev.platform_data = pd; 830} 831#endif /* CONFIG_SAMSUNG_DEV_PWM */ 832 833/* RTC */ 834 835#ifdef CONFIG_PLAT_S3C24XX 836static struct resource s3c_rtc_resource[] = { 837 [0] = DEFINE_RES_MEM(S3C24XX_PA_RTC, SZ_256), 838 [1] = DEFINE_RES_IRQ(IRQ_RTC), 839 [2] = DEFINE_RES_IRQ(IRQ_TICK), 840}; 841 842struct platform_device s3c_device_rtc = { 843 .name = "s3c2410-rtc", 844 .id = -1, 845 .num_resources = ARRAY_SIZE(s3c_rtc_resource), 846 .resource = s3c_rtc_resource, 847}; 848#endif /* CONFIG_PLAT_S3C24XX */ 849 850#ifdef CONFIG_S3C_DEV_RTC 851static struct resource s3c_rtc_resource[] = { 852 [0] = DEFINE_RES_MEM(S3C_PA_RTC, SZ_256), 853 [1] = DEFINE_RES_IRQ(IRQ_RTC_ALARM), 854 [2] = DEFINE_RES_IRQ(IRQ_RTC_TIC), 855}; 856 857struct platform_device s3c_device_rtc = { 858 .name = "s3c64xx-rtc", 859 .id = -1, 860 .num_resources = ARRAY_SIZE(s3c_rtc_resource), 861 .resource = s3c_rtc_resource, 862}; 863#endif /* CONFIG_S3C_DEV_RTC */ 864 865/* SDI */ 866 867#ifdef CONFIG_PLAT_S3C24XX 868static struct resource s3c_sdi_resource[] = { 869 [0] = DEFINE_RES_MEM(S3C24XX_PA_SDI, S3C24XX_SZ_SDI), 870 [1] = DEFINE_RES_IRQ(IRQ_SDI), 871}; 872 873struct platform_device s3c_device_sdi = { 874 .name = "s3c2410-sdi", 875 .id = -1, 876 .num_resources = ARRAY_SIZE(s3c_sdi_resource), 877 .resource = s3c_sdi_resource, 878}; 879 880void __init s3c24xx_mci_set_platdata(struct s3c24xx_mci_pdata *pdata) 881{ 882 s3c_set_platdata(pdata, sizeof(struct s3c24xx_mci_pdata), 883 &s3c_device_sdi); 884} 885#endif /* CONFIG_PLAT_S3C24XX */ 886 887/* SPI */ 888 889#ifdef CONFIG_PLAT_S3C24XX 890static struct resource s3c_spi0_resource[] = { 891 [0] = DEFINE_RES_MEM(S3C24XX_PA_SPI, SZ_32), 892 [1] = DEFINE_RES_IRQ(IRQ_SPI0), 893}; 894 895struct platform_device s3c_device_spi0 = { 896 .name = "s3c2410-spi", 897 .id = 0, 898 .num_resources = ARRAY_SIZE(s3c_spi0_resource), 899 .resource = s3c_spi0_resource, 900 .dev = { 901 .dma_mask = &samsung_device_dma_mask, 902 .coherent_dma_mask = DMA_BIT_MASK(32), 903 } 904}; 905 906static struct resource s3c_spi1_resource[] = { 907 [0] = DEFINE_RES_MEM(S3C24XX_PA_SPI1, SZ_32), 908 [1] = DEFINE_RES_IRQ(IRQ_SPI1), 909}; 910 911struct platform_device s3c_device_spi1 = { 912 .name = "s3c2410-spi", 913 .id = 1, 914 .num_resources = ARRAY_SIZE(s3c_spi1_resource), 915 .resource = s3c_spi1_resource, 916 .dev = { 917 .dma_mask = &samsung_device_dma_mask, 918 .coherent_dma_mask = DMA_BIT_MASK(32), 919 } 920}; 921#endif /* CONFIG_PLAT_S3C24XX */ 922 923/* Touchscreen */ 924 925#ifdef CONFIG_PLAT_S3C24XX 926static struct resource s3c_ts_resource[] = { 927 [0] = DEFINE_RES_MEM(S3C24XX_PA_ADC, S3C24XX_SZ_ADC), 928 [1] = DEFINE_RES_IRQ(IRQ_TC), 929}; 930 931struct platform_device s3c_device_ts = { 932 .name = "s3c2410-ts", 933 .id = -1, 934 .dev.parent = &s3c_device_adc.dev, 935 .num_resources = ARRAY_SIZE(s3c_ts_resource), 936 .resource = s3c_ts_resource, 937}; 938 939void __init s3c24xx_ts_set_platdata(struct s3c2410_ts_mach_info *hard_s3c2410ts_info) 940{ 941 s3c_set_platdata(hard_s3c2410ts_info, 942 sizeof(struct s3c2410_ts_mach_info), &s3c_device_ts); 943} 944#endif /* CONFIG_PLAT_S3C24XX */ 945 946#ifdef CONFIG_SAMSUNG_DEV_TS 947static struct resource s3c_ts_resource[] = { 948 [0] = DEFINE_RES_MEM(SAMSUNG_PA_ADC, SZ_256), 949 [1] = DEFINE_RES_IRQ(IRQ_TC), 950}; 951 952static struct s3c2410_ts_mach_info default_ts_data __initdata = { 953 .delay = 10000, 954 .presc = 49, 955 .oversampling_shift = 2, 956}; 957 958struct platform_device s3c_device_ts = { 959 .name = "s3c64xx-ts", 960 .id = -1, 961 .num_resources = ARRAY_SIZE(s3c_ts_resource), 962 .resource = s3c_ts_resource, 963}; 964 965void __init s3c24xx_ts_set_platdata(struct s3c2410_ts_mach_info *pd) 966{ 967 if (!pd) 968 pd = &default_ts_data; 969 970 s3c_set_platdata(pd, sizeof(struct s3c2410_ts_mach_info), 971 &s3c_device_ts); 972} 973#endif /* CONFIG_SAMSUNG_DEV_TS */ 974 975/* USB */ 976 977#ifdef CONFIG_S3C_DEV_USB_HOST 978static struct resource s3c_usb_resource[] = { 979 [0] = DEFINE_RES_MEM(S3C_PA_USBHOST, SZ_256), 980 [1] = DEFINE_RES_IRQ(IRQ_USBH), 981}; 982 983struct platform_device s3c_device_ohci = { 984 .name = "s3c2410-ohci", 985 .id = -1, 986 .num_resources = ARRAY_SIZE(s3c_usb_resource), 987 .resource = s3c_usb_resource, 988 .dev = { 989 .dma_mask = &samsung_device_dma_mask, 990 .coherent_dma_mask = DMA_BIT_MASK(32), 991 } 992}; 993 994/* 995 * s3c_ohci_set_platdata - initialise OHCI device platform data 996 * @info: The platform data. 997 * 998 * This call copies the @info passed in and sets the device .platform_data 999 * field to that copy. The @info is copied so that the original can be marked 1000 * __initdata. 1001 */ 1002 1003void __init s3c_ohci_set_platdata(struct s3c2410_hcd_info *info) 1004{ 1005 s3c_set_platdata(info, sizeof(struct s3c2410_hcd_info), 1006 &s3c_device_ohci); 1007} 1008#endif /* CONFIG_S3C_DEV_USB_HOST */ 1009 1010/* USB Device (Gadget) */ 1011 1012#ifdef CONFIG_PLAT_S3C24XX 1013static struct resource s3c_usbgadget_resource[] = { 1014 [0] = DEFINE_RES_MEM(S3C24XX_PA_USBDEV, S3C24XX_SZ_USBDEV), 1015 [1] = DEFINE_RES_IRQ(IRQ_USBD), 1016}; 1017 1018struct platform_device s3c_device_usbgadget = { 1019 .name = "s3c2410-usbgadget", 1020 .id = -1, 1021 .num_resources = ARRAY_SIZE(s3c_usbgadget_resource), 1022 .resource = s3c_usbgadget_resource, 1023}; 1024 1025void __init s3c24xx_udc_set_platdata(struct s3c2410_udc_mach_info *pd) 1026{ 1027 s3c_set_platdata(pd, sizeof(*pd), &s3c_device_usbgadget); 1028} 1029#endif /* CONFIG_PLAT_S3C24XX */ 1030 1031/* USB HSOTG */ 1032 1033#ifdef CONFIG_S3C_DEV_USB_HSOTG 1034static struct resource s3c_usb_hsotg_resources[] = { 1035 [0] = DEFINE_RES_MEM(S3C_PA_USB_HSOTG, SZ_128K), 1036 [1] = DEFINE_RES_IRQ(IRQ_OTG), 1037}; 1038 1039struct platform_device s3c_device_usb_hsotg = { 1040 .name = "s3c-hsotg", 1041 .id = -1, 1042 .num_resources = ARRAY_SIZE(s3c_usb_hsotg_resources), 1043 .resource = s3c_usb_hsotg_resources, 1044 .dev = { 1045 .dma_mask = &samsung_device_dma_mask, 1046 .coherent_dma_mask = DMA_BIT_MASK(32), 1047 }, 1048}; 1049 1050void __init dwc2_hsotg_set_platdata(struct dwc2_hsotg_plat *pd) 1051{ 1052 struct dwc2_hsotg_plat *npd; 1053 1054 npd = s3c_set_platdata(pd, sizeof(struct dwc2_hsotg_plat), 1055 &s3c_device_usb_hsotg); 1056 1057 if (!npd->phy_init) 1058 npd->phy_init = s5p_usb_phy_init; 1059 if (!npd->phy_exit) 1060 npd->phy_exit = s5p_usb_phy_exit; 1061} 1062#endif /* CONFIG_S3C_DEV_USB_HSOTG */ 1063 1064/* USB High Spped 2.0 Device (Gadget) */ 1065 1066#ifdef CONFIG_PLAT_S3C24XX 1067static struct resource s3c_hsudc_resource[] = { 1068 [0] = DEFINE_RES_MEM(S3C2416_PA_HSUDC, S3C2416_SZ_HSUDC), 1069 [1] = DEFINE_RES_IRQ(IRQ_USBD), 1070}; 1071 1072struct platform_device s3c_device_usb_hsudc = { 1073 .name = "s3c-hsudc", 1074 .id = -1, 1075 .num_resources = ARRAY_SIZE(s3c_hsudc_resource), 1076 .resource = s3c_hsudc_resource, 1077 .dev = { 1078 .dma_mask = &samsung_device_dma_mask, 1079 .coherent_dma_mask = DMA_BIT_MASK(32), 1080 }, 1081}; 1082 1083void __init s3c24xx_hsudc_set_platdata(struct s3c24xx_hsudc_platdata *pd) 1084{ 1085 s3c_set_platdata(pd, sizeof(*pd), &s3c_device_usb_hsudc); 1086} 1087#endif /* CONFIG_PLAT_S3C24XX */ 1088 1089/* WDT */ 1090 1091#ifdef CONFIG_S3C_DEV_WDT 1092static struct resource s3c_wdt_resource[] = { 1093 [0] = DEFINE_RES_MEM(S3C_PA_WDT, SZ_1K), 1094 [1] = DEFINE_RES_IRQ(IRQ_WDT), 1095}; 1096 1097struct platform_device s3c_device_wdt = { 1098 .name = "s3c2410-wdt", 1099 .id = -1, 1100 .num_resources = ARRAY_SIZE(s3c_wdt_resource), 1101 .resource = s3c_wdt_resource, 1102}; 1103#endif /* CONFIG_S3C_DEV_WDT */ 1104 1105#ifdef CONFIG_S3C64XX_DEV_SPI0 1106static struct resource s3c64xx_spi0_resource[] = { 1107 [0] = DEFINE_RES_MEM(S3C_PA_SPI0, SZ_256), 1108 [1] = DEFINE_RES_DMA(DMACH_SPI0_TX), 1109 [2] = DEFINE_RES_DMA(DMACH_SPI0_RX), 1110 [3] = DEFINE_RES_IRQ(IRQ_SPI0), 1111}; 1112 1113struct platform_device s3c64xx_device_spi0 = { 1114 .name = "s3c6410-spi", 1115 .id = 0, 1116 .num_resources = ARRAY_SIZE(s3c64xx_spi0_resource), 1117 .resource = s3c64xx_spi0_resource, 1118 .dev = { 1119 .dma_mask = &samsung_device_dma_mask, 1120 .coherent_dma_mask = DMA_BIT_MASK(32), 1121 }, 1122}; 1123 1124void __init s3c64xx_spi0_set_platdata(int (*cfg_gpio)(void), int src_clk_nr, 1125 int num_cs) 1126{ 1127 struct s3c64xx_spi_info pd; 1128 1129 /* Reject invalid configuration */ 1130 if (!num_cs || src_clk_nr < 0) { 1131 pr_err("%s: Invalid SPI configuration\n", __func__); 1132 return; 1133 } 1134 1135 pd.num_cs = num_cs; 1136 pd.src_clk_nr = src_clk_nr; 1137 pd.cfg_gpio = (cfg_gpio) ? cfg_gpio : s3c64xx_spi0_cfg_gpio; 1138#if defined(CONFIG_PL330_DMA) 1139 pd.filter = pl330_filter; 1140#elif defined(CONFIG_S3C64XX_PL080) 1141 pd.filter = pl08x_filter_id; 1142#elif defined(CONFIG_S3C24XX_DMAC) 1143 pd.filter = s3c24xx_dma_filter; 1144#endif 1145 1146 s3c_set_platdata(&pd, sizeof(pd), &s3c64xx_device_spi0); 1147} 1148#endif /* CONFIG_S3C64XX_DEV_SPI0 */ 1149 1150#ifdef CONFIG_S3C64XX_DEV_SPI1 1151static struct resource s3c64xx_spi1_resource[] = { 1152 [0] = DEFINE_RES_MEM(S3C_PA_SPI1, SZ_256), 1153 [1] = DEFINE_RES_DMA(DMACH_SPI1_TX), 1154 [2] = DEFINE_RES_DMA(DMACH_SPI1_RX), 1155 [3] = DEFINE_RES_IRQ(IRQ_SPI1), 1156}; 1157 1158struct platform_device s3c64xx_device_spi1 = { 1159 .name = "s3c6410-spi", 1160 .id = 1, 1161 .num_resources = ARRAY_SIZE(s3c64xx_spi1_resource), 1162 .resource = s3c64xx_spi1_resource, 1163 .dev = { 1164 .dma_mask = &samsung_device_dma_mask, 1165 .coherent_dma_mask = DMA_BIT_MASK(32), 1166 }, 1167}; 1168 1169void __init s3c64xx_spi1_set_platdata(int (*cfg_gpio)(void), int src_clk_nr, 1170 int num_cs) 1171{ 1172 struct s3c64xx_spi_info pd; 1173 1174 /* Reject invalid configuration */ 1175 if (!num_cs || src_clk_nr < 0) { 1176 pr_err("%s: Invalid SPI configuration\n", __func__); 1177 return; 1178 } 1179 1180 pd.num_cs = num_cs; 1181 pd.src_clk_nr = src_clk_nr; 1182 pd.cfg_gpio = (cfg_gpio) ? cfg_gpio : s3c64xx_spi1_cfg_gpio; 1183#if defined(CONFIG_PL330_DMA) 1184 pd.filter = pl330_filter; 1185#elif defined(CONFIG_S3C64XX_PL080) 1186 pd.filter = pl08x_filter_id; 1187#endif 1188 1189 s3c_set_platdata(&pd, sizeof(pd), &s3c64xx_device_spi1); 1190} 1191#endif /* CONFIG_S3C64XX_DEV_SPI1 */ 1192 1193#ifdef CONFIG_S3C64XX_DEV_SPI2 1194static struct resource s3c64xx_spi2_resource[] = { 1195 [0] = DEFINE_RES_MEM(S3C_PA_SPI2, SZ_256), 1196 [1] = DEFINE_RES_DMA(DMACH_SPI2_TX), 1197 [2] = DEFINE_RES_DMA(DMACH_SPI2_RX), 1198 [3] = DEFINE_RES_IRQ(IRQ_SPI2), 1199}; 1200 1201struct platform_device s3c64xx_device_spi2 = { 1202 .name = "s3c6410-spi", 1203 .id = 2, 1204 .num_resources = ARRAY_SIZE(s3c64xx_spi2_resource), 1205 .resource = s3c64xx_spi2_resource, 1206 .dev = { 1207 .dma_mask = &samsung_device_dma_mask, 1208 .coherent_dma_mask = DMA_BIT_MASK(32), 1209 }, 1210}; 1211 1212void __init s3c64xx_spi2_set_platdata(int (*cfg_gpio)(void), int src_clk_nr, 1213 int num_cs) 1214{ 1215 struct s3c64xx_spi_info pd; 1216 1217 /* Reject invalid configuration */ 1218 if (!num_cs || src_clk_nr < 0) { 1219 pr_err("%s: Invalid SPI configuration\n", __func__); 1220 return; 1221 } 1222 1223 pd.num_cs = num_cs; 1224 pd.src_clk_nr = src_clk_nr; 1225 pd.cfg_gpio = (cfg_gpio) ? cfg_gpio : s3c64xx_spi2_cfg_gpio; 1226#if defined(CONFIG_PL330_DMA) 1227 pd.filter = pl330_filter; 1228#elif defined(CONFIG_S3C64XX_PL080) 1229 pd.filter = pl08x_filter_id; 1230#endif 1231 1232 s3c_set_platdata(&pd, sizeof(pd), &s3c64xx_device_spi2); 1233} 1234#endif /* CONFIG_S3C64XX_DEV_SPI2 */ 1235