arch/arm/mach-pxa/devices.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/module.h>
   3 #include <linux/kernel.h>
   4 #include <linux/init.h>
   5 #include <linux/platform_device.h>
   6 #include <linux/clkdev.h>
   7 #include <linux/clk-provider.h>
   8 #include <linux/dma-mapping.h>
   9 #include <linux/dmaengine.h>
  10 #include <linux/spi/pxa2xx_spi.h>
  11 #include <linux/platform_data/i2c-pxa.h>
  12
  13 #include "udc.h"
  14 #include <linux/platform_data/usb-pxa3xx-ulpi.h>
  15 #include <linux/platform_data/video-pxafb.h>
  16 #include <linux/platform_data/mmc-pxamci.h>
  17 #include <linux/platform_data/irda-pxaficp.h>
  18 #include <mach/irqs.h>
  19 #include <linux/platform_data/usb-ohci-pxa27x.h>
  20 #include <linux/platform_data/keypad-pxa27x.h>
  21 #include <linux/platform_data/media/camera-pxa.h>
  22 #include <mach/audio.h>
  23 #include <mach/hardware.h>
  24 #include <linux/platform_data/mmp_dma.h>
  25 #include <linux/platform_data/mtd-nand-pxa3xx.h>
  26
  27 #include "devices.h"
  28 #include "generic.h"
  29
  30 void __init pxa_register_device(struct platform_device *dev, void *data)
  31 {
  32         int ret;
  33
  34         dev->dev.platform_data = data;
  35
  36         ret = platform_device_register(dev);
  37         if (ret)
  38                 dev_err(&dev->dev, "unable to register device: %d\n", ret);
  39 }
  40
  41 static struct resource pxa_resource_pmu = {
  42         .start  = IRQ_PMU,
  43         .end    = IRQ_PMU,
  44         .flags  = IORESOURCE_IRQ,
  45 };
  46
  47 struct platform_device pxa_device_pmu = {
  48         .name           = "xscale-pmu",
  49         .id             = -1,
  50         .resource       = &pxa_resource_pmu,
  51         .num_resources  = 1,
  52 };
  53
  54 static struct resource pxamci_resources[] = {
  55         [0] = {
  56                 .start  = 0x41100000,
  57                 .end    = 0x41100fff,
  58                 .flags  = IORESOURCE_MEM,
  59         },
  60         [1] = {
  61                 .start  = IRQ_MMC,
  62                 .end    = IRQ_MMC,
  63                 .flags  = IORESOURCE_IRQ,
  64         },
  65 };
  66
  67 static u64 pxamci_dmamask = 0xffffffffUL;
  68
  69 struct platform_device pxa_device_mci = {
  70         .name           = "pxa2xx-mci",
  71         .id             = 0,
  72         .dev            = {
  73                 .dma_mask = &pxamci_dmamask,
  74                 .coherent_dma_mask = 0xffffffff,
  75         },
  76         .num_resources  = ARRAY_SIZE(pxamci_resources),
  77         .resource       = pxamci_resources,
  78 };
  79
  80 void __init pxa_set_mci_info(struct pxamci_platform_data *info)
  81 {
  82         pxa_register_device(&pxa_device_mci, info);
  83 }
  84
  85
  86 static struct pxa2xx_udc_mach_info pxa_udc_info = {
  87         .gpio_pullup = -1,
  88 };
  89
  90 void __init pxa_set_udc_info(struct pxa2xx_udc_mach_info *info)
  91 {
  92         memcpy(&pxa_udc_info, info, sizeof *info);
  93 }
  94
  95 static struct resource pxa2xx_udc_resources[] = {
  96         [0] = {
  97                 .start  = 0x40600000,
  98                 .end    = 0x4060ffff,
  99                 .flags  = IORESOURCE_MEM,
 100         },
 101         [1] = {
 102                 .start  = IRQ_USB,
 103                 .end    = IRQ_USB,
 104                 .flags  = IORESOURCE_IRQ,
 105         },
 106 };
 107
 108 static u64 udc_dma_mask = ~(u32)0;
 109
 110 struct platform_device pxa25x_device_udc = {
 111         .name           = "pxa25x-udc",
 112         .id             = -1,
 113         .resource       = pxa2xx_udc_resources,
 114         .num_resources  = ARRAY_SIZE(pxa2xx_udc_resources),
 115         .dev            =  {
 116                 .platform_data  = &pxa_udc_info,
 117                 .dma_mask       = &udc_dma_mask,
 118         }
 119 };
 120
 121 struct platform_device pxa27x_device_udc = {
 122         .name           = "pxa27x-udc",
 123         .id             = -1,
 124         .resource       = pxa2xx_udc_resources,
 125         .num_resources  = ARRAY_SIZE(pxa2xx_udc_resources),
 126         .dev            =  {
 127                 .platform_data  = &pxa_udc_info,
 128                 .dma_mask       = &udc_dma_mask,
 129         }
 130 };
 131
 132 #ifdef CONFIG_PXA3xx
 133 static struct resource pxa3xx_u2d_resources[] = {
 134         [0] = {
 135                 .start  = 0x54100000,
 136                 .end    = 0x54100fff,
 137                 .flags  = IORESOURCE_MEM,
 138         },
 139         [1] = {
 140                 .start  = IRQ_USB2,
 141                 .end    = IRQ_USB2,
 142                 .flags  = IORESOURCE_IRQ,
 143         },
 144 };
 145
 146 struct platform_device pxa3xx_device_u2d = {
 147         .name           = "pxa3xx-u2d",
 148         .id             = -1,
 149         .resource       = pxa3xx_u2d_resources,
 150         .num_resources  = ARRAY_SIZE(pxa3xx_u2d_resources),
 151 };
 152
 153 void __init pxa3xx_set_u2d_info(struct pxa3xx_u2d_platform_data *info)
 154 {
 155         pxa_register_device(&pxa3xx_device_u2d, info);
 156 }
 157 #endif /* CONFIG_PXA3xx */
 158
 159 static struct resource pxafb_resources[] = {
 160         [0] = {
 161                 .start  = 0x44000000,
 162                 .end    = 0x4400ffff,
 163                 .flags  = IORESOURCE_MEM,
 164         },
 165         [1] = {
 166                 .start  = IRQ_LCD,
 167                 .end    = IRQ_LCD,
 168                 .flags  = IORESOURCE_IRQ,
 169         },
 170 };
 171
 172 static u64 fb_dma_mask = ~(u64)0;
 173
 174 struct platform_device pxa_device_fb = {
 175         .name           = "pxa2xx-fb",
 176         .id             = -1,
 177         .dev            = {
 178                 .dma_mask       = &fb_dma_mask,
 179                 .coherent_dma_mask = 0xffffffff,
 180         },
 181         .num_resources  = ARRAY_SIZE(pxafb_resources),
 182         .resource       = pxafb_resources,
 183 };
 184
 185 void __init pxa_set_fb_info(struct device *parent, struct pxafb_mach_info *info)
 186 {
 187         pxa_device_fb.dev.parent = parent;
 188         pxa_register_device(&pxa_device_fb, info);
 189 }
 190
 191 static struct resource pxa_resource_ffuart[] = {
 192         {
 193                 .start  = 0x40100000,
 194                 .end    = 0x40100023,
 195                 .flags  = IORESOURCE_MEM,
 196         }, {
 197                 .start  = IRQ_FFUART,
 198                 .end    = IRQ_FFUART,
 199                 .flags  = IORESOURCE_IRQ,
 200         }
 201 };
 202
 203 struct platform_device pxa_device_ffuart = {
 204         .name           = "pxa2xx-uart",
 205         .id             = 0,
 206         .resource       = pxa_resource_ffuart,
 207         .num_resources  = ARRAY_SIZE(pxa_resource_ffuart),
 208 };
 209
 210 void __init pxa_set_ffuart_info(void *info)
 211 {
 212         pxa_register_device(&pxa_device_ffuart, info);
 213 }
 214
 215 static struct resource pxa_resource_btuart[] = {
 216         {
 217                 .start  = 0x40200000,
 218                 .end    = 0x40200023,
 219                 .flags  = IORESOURCE_MEM,
 220         }, {
 221                 .start  = IRQ_BTUART,
 222                 .end    = IRQ_BTUART,
 223                 .flags  = IORESOURCE_IRQ,
 224         }
 225 };
 226
 227 struct platform_device pxa_device_btuart = {
 228         .name           = "pxa2xx-uart",
 229         .id             = 1,
 230         .resource       = pxa_resource_btuart,
 231         .num_resources  = ARRAY_SIZE(pxa_resource_btuart),
 232 };
 233
 234 void __init pxa_set_btuart_info(void *info)
 235 {
 236         pxa_register_device(&pxa_device_btuart, info);
 237 }
 238
 239 static struct resource pxa_resource_stuart[] = {
 240         {
 241                 .start  = 0x40700000,
 242                 .end    = 0x40700023,
 243                 .flags  = IORESOURCE_MEM,
 244         }, {
 245                 .start  = IRQ_STUART,
 246                 .end    = IRQ_STUART,
 247                 .flags  = IORESOURCE_IRQ,
 248         }
 249 };
 250
 251 struct platform_device pxa_device_stuart = {
 252         .name           = "pxa2xx-uart",
 253         .id             = 2,
 254         .resource       = pxa_resource_stuart,
 255         .num_resources  = ARRAY_SIZE(pxa_resource_stuart),
 256 };
 257
 258 void __init pxa_set_stuart_info(void *info)
 259 {
 260         pxa_register_device(&pxa_device_stuart, info);
 261 }
 262
 263 static struct resource pxa_resource_hwuart[] = {
 264         {
 265                 .start  = 0x41600000,
 266                 .end    = 0x4160002F,
 267                 .flags  = IORESOURCE_MEM,
 268         }, {
 269                 .start  = IRQ_HWUART,
 270                 .end    = IRQ_HWUART,
 271                 .flags  = IORESOURCE_IRQ,
 272         }
 273 };
 274
 275 struct platform_device pxa_device_hwuart = {
 276         .name           = "pxa2xx-uart",
 277         .id             = 3,
 278         .resource       = pxa_resource_hwuart,
 279         .num_resources  = ARRAY_SIZE(pxa_resource_hwuart),
 280 };
 281
 282 void __init pxa_set_hwuart_info(void *info)
 283 {
 284         if (cpu_is_pxa255())
 285                 pxa_register_device(&pxa_device_hwuart, info);
 286         else
 287                 pr_info("UART: Ignoring attempt to register HWUART on non-PXA255 hardware");
 288 }
 289
 290 static struct resource pxai2c_resources[] = {
 291         {
 292                 .start  = 0x40301680,
 293                 .end    = 0x403016a3,
 294                 .flags  = IORESOURCE_MEM,
 295         }, {
 296                 .start  = IRQ_I2C,
 297                 .end    = IRQ_I2C,
 298                 .flags  = IORESOURCE_IRQ,
 299         },
 300 };
 301
 302 struct platform_device pxa_device_i2c = {
 303         .name           = "pxa2xx-i2c",
 304         .id             = 0,
 305         .resource       = pxai2c_resources,
 306         .num_resources  = ARRAY_SIZE(pxai2c_resources),
 307 };
 308
 309 void __init pxa_set_i2c_info(struct i2c_pxa_platform_data *info)
 310 {
 311         pxa_register_device(&pxa_device_i2c, info);
 312 }
 313
 314 #ifdef CONFIG_PXA27x
 315 static struct resource pxa27x_resources_i2c_power[] = {
 316         {
 317                 .start  = 0x40f00180,
 318                 .end    = 0x40f001a3,
 319                 .flags  = IORESOURCE_MEM,
 320         }, {
 321                 .start  = IRQ_PWRI2C,
 322                 .end    = IRQ_PWRI2C,
 323                 .flags  = IORESOURCE_IRQ,
 324         },
 325 };
 326
 327 struct platform_device pxa27x_device_i2c_power = {
 328         .name           = "pxa2xx-i2c",
 329         .id             = 1,
 330         .resource       = pxa27x_resources_i2c_power,
 331         .num_resources  = ARRAY_SIZE(pxa27x_resources_i2c_power),
 332 };
 333 #endif
 334
 335 static struct resource pxai2s_resources[] = {
 336         {
 337                 .start  = 0x40400000,
 338                 .end    = 0x40400083,
 339                 .flags  = IORESOURCE_MEM,
 340         }, {
 341                 .start  = IRQ_I2S,
 342                 .end    = IRQ_I2S,
 343                 .flags  = IORESOURCE_IRQ,
 344         },
 345 };
 346
 347 struct platform_device pxa_device_i2s = {
 348         .name           = "pxa2xx-i2s",
 349         .id             = -1,
 350         .resource       = pxai2s_resources,
 351         .num_resources  = ARRAY_SIZE(pxai2s_resources),
 352 };
 353
 354 struct platform_device pxa_device_asoc_ssp1 = {
 355         .name           = "pxa-ssp-dai",
 356         .id             = 0,
 357 };
 358
 359 struct platform_device pxa_device_asoc_ssp2= {
 360         .name           = "pxa-ssp-dai",
 361         .id             = 1,
 362 };
 363
 364 struct platform_device pxa_device_asoc_ssp3 = {
 365         .name           = "pxa-ssp-dai",
 366         .id             = 2,
 367 };
 368
 369 struct platform_device pxa_device_asoc_ssp4 = {
 370         .name           = "pxa-ssp-dai",
 371         .id             = 3,
 372 };
 373
 374 struct platform_device pxa_device_asoc_platform = {
 375         .name           = "pxa-pcm-audio",
 376         .id             = -1,
 377 };
 378
 379 static u64 pxaficp_dmamask = ~(u32)0;
 380
 381 static struct resource pxa_ir_resources[] = {
 382         [0] = {
 383                 .start  = IRQ_STUART,
 384                 .end    = IRQ_STUART,
 385                 .flags  = IORESOURCE_IRQ,
 386         },
 387         [1] = {
 388                 .start  = IRQ_ICP,
 389                 .end    = IRQ_ICP,
 390                 .flags  = IORESOURCE_IRQ,
 391         },
 392         [3] = {
 393                 .start  = 0x40800000,
 394                 .end    = 0x4080001b,
 395                 .flags  = IORESOURCE_MEM,
 396         },
 397         [4] = {
 398                 .start  = 0x40700000,
 399                 .end    = 0x40700023,
 400                 .flags  = IORESOURCE_MEM,
 401         },
 402 };
 403
 404 struct platform_device pxa_device_ficp = {
 405         .name           = "pxa2xx-ir",
 406         .id             = -1,
 407         .num_resources  = ARRAY_SIZE(pxa_ir_resources),
 408         .resource       = pxa_ir_resources,
 409         .dev            = {
 410                 .dma_mask = &pxaficp_dmamask,
 411                 .coherent_dma_mask = 0xffffffff,
 412         },
 413 };
 414
 415 void __init pxa_set_ficp_info(struct pxaficp_platform_data *info)
 416 {
 417         pxa_register_device(&pxa_device_ficp, info);
 418 }
 419
 420 static struct resource pxa_rtc_resources[] = {
 421         [0] = {
 422                 .start  = 0x40900000,
 423                 .end    = 0x40900000 + 0x3b,
 424                 .flags  = IORESOURCE_MEM,
 425         },
 426         [1] = {
 427                 .start  = IRQ_RTC1Hz,
 428                 .end    = IRQ_RTC1Hz,
 429                 .name   = "rtc 1Hz",
 430                 .flags  = IORESOURCE_IRQ,
 431         },
 432         [2] = {
 433                 .start  = IRQ_RTCAlrm,
 434                 .end    = IRQ_RTCAlrm,
 435                 .name   = "rtc alarm",
 436                 .flags  = IORESOURCE_IRQ,
 437         },
 438 };
 439
 440 struct platform_device pxa_device_rtc = {
 441         .name           = "pxa-rtc",
 442         .id             = -1,
 443         .num_resources  = ARRAY_SIZE(pxa_rtc_resources),
 444         .resource       = pxa_rtc_resources,
 445 };
 446
 447 struct platform_device sa1100_device_rtc = {
 448         .name           = "sa1100-rtc",
 449         .id             = -1,
 450         .num_resources  = ARRAY_SIZE(pxa_rtc_resources),
 451         .resource       = pxa_rtc_resources,
 452 };
 453
 454 static struct resource pxa_ac97_resources[] = {
 455         [0] = {
 456                 .start  = 0x40500000,
 457                 .end    = 0x40500000 + 0xfff,
 458                 .flags  = IORESOURCE_MEM,
 459         },
 460         [1] = {
 461                 .start  = IRQ_AC97,
 462                 .end    = IRQ_AC97,
 463                 .flags  = IORESOURCE_IRQ,
 464         },
 465 };
 466
 467 static u64 pxa_ac97_dmamask = 0xffffffffUL;
 468
 469 struct platform_device pxa_device_ac97 = {
 470         .name           = "pxa2xx-ac97",
 471         .id             = -1,
 472         .dev            = {
 473                 .dma_mask = &pxa_ac97_dmamask,
 474                 .coherent_dma_mask = 0xffffffff,
 475         },
 476         .num_resources  = ARRAY_SIZE(pxa_ac97_resources),
 477         .resource       = pxa_ac97_resources,
 478 };
 479
 480 void __init pxa_set_ac97_info(pxa2xx_audio_ops_t *ops)
 481 {
 482         int ret;
 483
 484         ret = clk_add_alias("ac97_clk", "pxa2xx-ac97:0", "AC97CLK",
 485                            &pxa_device_ac97.dev);
 486         if (ret)
 487                 pr_err("PXA AC97 clock1 alias error: %d\n", ret);
 488
 489         ret = clk_add_alias("ac97_clk", "pxa2xx-ac97:1", "AC97CLK",
 490                             &pxa_device_ac97.dev);
 491         if (ret)
 492                 pr_err("PXA AC97 clock2 alias error: %d\n", ret);
 493
 494         pxa_register_device(&pxa_device_ac97, ops);
 495 }
 496
 497 #ifdef CONFIG_PXA25x
 498
 499 static struct resource pxa25x_resource_pwm0[] = {
 500         [0] = {
 501                 .start  = 0x40b00000,
 502                 .end    = 0x40b0000f,
 503                 .flags  = IORESOURCE_MEM,
 504         },
 505 };
 506
 507 struct platform_device pxa25x_device_pwm0 = {
 508         .name           = "pxa25x-pwm",
 509         .id             = 0,
 510         .resource       = pxa25x_resource_pwm0,
 511         .num_resources  = ARRAY_SIZE(pxa25x_resource_pwm0),
 512 };
 513
 514 static struct resource pxa25x_resource_pwm1[] = {
 515         [0] = {
 516                 .start  = 0x40c00000,
 517                 .end    = 0x40c0000f,
 518                 .flags  = IORESOURCE_MEM,
 519         },
 520 };
 521
 522 struct platform_device pxa25x_device_pwm1 = {
 523         .name           = "pxa25x-pwm",
 524         .id             = 1,
 525         .resource       = pxa25x_resource_pwm1,
 526         .num_resources  = ARRAY_SIZE(pxa25x_resource_pwm1),
 527 };
 528
 529 static u64 pxa25x_ssp_dma_mask = DMA_BIT_MASK(32);
 530
 531 static struct resource pxa25x_resource_ssp[] = {
 532         [0] = {
 533                 .start  = 0x41000000,
 534                 .end    = 0x4100001f,
 535                 .flags  = IORESOURCE_MEM,
 536         },
 537         [1] = {
 538                 .start  = IRQ_SSP,
 539                 .end    = IRQ_SSP,
 540                 .flags  = IORESOURCE_IRQ,
 541         },
 542 };
 543
 544 struct platform_device pxa25x_device_ssp = {
 545         .name           = "pxa25x-ssp",
 546         .id             = 0,
 547         .dev            = {
 548                 .dma_mask = &pxa25x_ssp_dma_mask,
 549                 .coherent_dma_mask = DMA_BIT_MASK(32),
 550         },
 551         .resource       = pxa25x_resource_ssp,
 552         .num_resources  = ARRAY_SIZE(pxa25x_resource_ssp),
 553 };
 554
 555 static u64 pxa25x_nssp_dma_mask = DMA_BIT_MASK(32);
 556
 557 static struct resource pxa25x_resource_nssp[] = {
 558         [0] = {
 559                 .start  = 0x41400000,
 560                 .end    = 0x4140002f,
 561                 .flags  = IORESOURCE_MEM,
 562         },
 563         [1] = {
 564                 .start  = IRQ_NSSP,
 565                 .end    = IRQ_NSSP,
 566                 .flags  = IORESOURCE_IRQ,
 567         },
 568 };
 569
 570 struct platform_device pxa25x_device_nssp = {
 571         .name           = "pxa25x-nssp",
 572         .id             = 1,
 573         .dev            = {
 574                 .dma_mask = &pxa25x_nssp_dma_mask,
 575                 .coherent_dma_mask = DMA_BIT_MASK(32),
 576         },
 577         .resource       = pxa25x_resource_nssp,
 578         .num_resources  = ARRAY_SIZE(pxa25x_resource_nssp),
 579 };
 580
 581 static u64 pxa25x_assp_dma_mask = DMA_BIT_MASK(32);
 582
 583 static struct resource pxa25x_resource_assp[] = {
 584         [0] = {
 585                 .start  = 0x41500000,
 586                 .end    = 0x4150002f,
 587                 .flags  = IORESOURCE_MEM,
 588         },
 589         [1] = {
 590                 .start  = IRQ_ASSP,
 591                 .end    = IRQ_ASSP,
 592                 .flags  = IORESOURCE_IRQ,
 593         },
 594 };
 595
 596 struct platform_device pxa25x_device_assp = {
 597         /* ASSP is basically equivalent to NSSP */
 598         .name           = "pxa25x-nssp",
 599         .id             = 2,
 600         .dev            = {
 601                 .dma_mask = &pxa25x_assp_dma_mask,
 602                 .coherent_dma_mask = DMA_BIT_MASK(32),
 603         },
 604         .resource       = pxa25x_resource_assp,
 605         .num_resources  = ARRAY_SIZE(pxa25x_resource_assp),
 606 };
 607 #endif /* CONFIG_PXA25x */
 608
 609 #if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
 610 static struct resource pxa27x_resource_camera[] = {
 611         [0] = {
 612                 .start  = 0x50000000,
 613                 .end    = 0x50000fff,
 614                 .flags  = IORESOURCE_MEM,
 615         },
 616         [1] = {
 617                 .start  = IRQ_CAMERA,
 618                 .end    = IRQ_CAMERA,
 619                 .flags  = IORESOURCE_IRQ,
 620         },
 621 };
 622
 623 static u64 pxa27x_dma_mask_camera = DMA_BIT_MASK(32);
 624
 625 static struct platform_device pxa27x_device_camera = {
 626         .name           = "pxa27x-camera",
 627         .id             = 0, /* This is used to put cameras on this interface */
 628         .dev            = {
 629                 .dma_mask               = &pxa27x_dma_mask_camera,
 630                 .coherent_dma_mask      = 0xffffffff,
 631         },
 632         .num_resources  = ARRAY_SIZE(pxa27x_resource_camera),
 633         .resource       = pxa27x_resource_camera,
 634 };
 635
 636 void __init pxa_set_camera_info(struct pxacamera_platform_data *info)
 637 {
 638         struct clk *mclk;
 639
 640         /* Register a fixed-rate clock for camera sensors. */
 641         mclk = clk_register_fixed_rate(NULL, "pxa_camera_clk", NULL, 0,
 642                                              info->mclk_10khz * 10000);
 643         if (!IS_ERR(mclk))
 644                 clkdev_create(mclk, "mclk", NULL);
 645         pxa_register_device(&pxa27x_device_camera, info);
 646 }
 647
 648 static u64 pxa27x_ohci_dma_mask = DMA_BIT_MASK(32);
 649
 650 static struct resource pxa27x_resource_ohci[] = {
 651         [0] = {
 652                 .start  = 0x4C000000,
 653                 .end    = 0x4C00ff6f,
 654                 .flags  = IORESOURCE_MEM,
 655         },
 656         [1] = {
 657                 .start  = IRQ_USBH1,
 658                 .end    = IRQ_USBH1,
 659                 .flags  = IORESOURCE_IRQ,
 660         },
 661 };
 662
 663 struct platform_device pxa27x_device_ohci = {
 664         .name           = "pxa27x-ohci",
 665         .id             = -1,
 666         .dev            = {
 667                 .dma_mask = &pxa27x_ohci_dma_mask,
 668                 .coherent_dma_mask = DMA_BIT_MASK(32),
 669         },
 670         .num_resources  = ARRAY_SIZE(pxa27x_resource_ohci),
 671         .resource       = pxa27x_resource_ohci,
 672 };
 673
 674 void __init pxa_set_ohci_info(struct pxaohci_platform_data *info)
 675 {
 676         pxa_register_device(&pxa27x_device_ohci, info);
 677 }
 678 #endif /* CONFIG_PXA27x || CONFIG_PXA3xx */
 679
 680 #if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
 681 static struct resource pxa27x_resource_keypad[] = {
 682         [0] = {
 683                 .start  = 0x41500000,
 684                 .end    = 0x4150004c,
 685                 .flags  = IORESOURCE_MEM,
 686         },
 687         [1] = {
 688                 .start  = IRQ_KEYPAD,
 689                 .end    = IRQ_KEYPAD,
 690                 .flags  = IORESOURCE_IRQ,
 691         },
 692 };
 693
 694 struct platform_device pxa27x_device_keypad = {
 695         .name           = "pxa27x-keypad",
 696         .id             = -1,
 697         .resource       = pxa27x_resource_keypad,
 698         .num_resources  = ARRAY_SIZE(pxa27x_resource_keypad),
 699 };
 700
 701 void __init pxa_set_keypad_info(struct pxa27x_keypad_platform_data *info)
 702 {
 703         pxa_register_device(&pxa27x_device_keypad, info);
 704 }
 705
 706 static u64 pxa27x_ssp1_dma_mask = DMA_BIT_MASK(32);
 707
 708 static struct resource pxa27x_resource_ssp1[] = {
 709         [0] = {
 710                 .start  = 0x41000000,
 711                 .end    = 0x4100003f,
 712                 .flags  = IORESOURCE_MEM,
 713         },
 714         [1] = {
 715                 .start  = IRQ_SSP,
 716                 .end    = IRQ_SSP,
 717                 .flags  = IORESOURCE_IRQ,
 718         },
 719 };
 720
 721 struct platform_device pxa27x_device_ssp1 = {
 722         .name           = "pxa27x-ssp",
 723         .id             = 0,
 724         .dev            = {
 725                 .dma_mask = &pxa27x_ssp1_dma_mask,
 726                 .coherent_dma_mask = DMA_BIT_MASK(32),
 727         },
 728         .resource       = pxa27x_resource_ssp1,
 729         .num_resources  = ARRAY_SIZE(pxa27x_resource_ssp1),
 730 };
 731
 732 static u64 pxa27x_ssp2_dma_mask = DMA_BIT_MASK(32);
 733
 734 static struct resource pxa27x_resource_ssp2[] = {
 735         [0] = {
 736                 .start  = 0x41700000,
 737                 .end    = 0x4170003f,
 738                 .flags  = IORESOURCE_MEM,
 739         },
 740         [1] = {
 741                 .start  = IRQ_SSP2,
 742                 .end    = IRQ_SSP2,
 743                 .flags  = IORESOURCE_IRQ,
 744         },
 745 };
 746
 747 struct platform_device pxa27x_device_ssp2 = {
 748         .name           = "pxa27x-ssp",
 749         .id             = 1,
 750         .dev            = {
 751                 .dma_mask = &pxa27x_ssp2_dma_mask,
 752                 .coherent_dma_mask = DMA_BIT_MASK(32),
 753         },
 754         .resource       = pxa27x_resource_ssp2,
 755         .num_resources  = ARRAY_SIZE(pxa27x_resource_ssp2),
 756 };
 757
 758 static u64 pxa27x_ssp3_dma_mask = DMA_BIT_MASK(32);
 759
 760 static struct resource pxa27x_resource_ssp3[] = {
 761         [0] = {
 762                 .start  = 0x41900000,
 763                 .end    = 0x4190003f,
 764                 .flags  = IORESOURCE_MEM,
 765         },
 766         [1] = {
 767                 .start  = IRQ_SSP3,
 768                 .end    = IRQ_SSP3,
 769                 .flags  = IORESOURCE_IRQ,
 770         },
 771 };
 772
 773 struct platform_device pxa27x_device_ssp3 = {
 774         .name           = "pxa27x-ssp",
 775         .id             = 2,
 776         .dev            = {
 777                 .dma_mask = &pxa27x_ssp3_dma_mask,
 778                 .coherent_dma_mask = DMA_BIT_MASK(32),
 779         },
 780         .resource       = pxa27x_resource_ssp3,
 781         .num_resources  = ARRAY_SIZE(pxa27x_resource_ssp3),
 782 };
 783
 784 static struct resource pxa27x_resource_pwm0[] = {
 785         [0] = {
 786                 .start  = 0x40b00000,
 787                 .end    = 0x40b0001f,
 788                 .flags  = IORESOURCE_MEM,
 789         },
 790 };
 791
 792 struct platform_device pxa27x_device_pwm0 = {
 793         .name           = "pxa27x-pwm",
 794         .id             = 0,
 795         .resource       = pxa27x_resource_pwm0,
 796         .num_resources  = ARRAY_SIZE(pxa27x_resource_pwm0),
 797 };
 798
 799 static struct resource pxa27x_resource_pwm1[] = {
 800         [0] = {
 801                 .start  = 0x40c00000,
 802                 .end    = 0x40c0001f,
 803                 .flags  = IORESOURCE_MEM,
 804         },
 805 };
 806
 807 struct platform_device pxa27x_device_pwm1 = {
 808         .name           = "pxa27x-pwm",
 809         .id             = 1,
 810         .resource       = pxa27x_resource_pwm1,
 811         .num_resources  = ARRAY_SIZE(pxa27x_resource_pwm1),
 812 };
 813 #endif /* CONFIG_PXA27x || CONFIG_PXA3xx */
 814
 815 #ifdef CONFIG_PXA3xx
 816 static struct resource pxa3xx_resources_mci2[] = {
 817         [0] = {
 818                 .start  = 0x42000000,
 819                 .end    = 0x42000fff,
 820                 .flags  = IORESOURCE_MEM,
 821         },
 822         [1] = {
 823                 .start  = IRQ_MMC2,
 824                 .end    = IRQ_MMC2,
 825                 .flags  = IORESOURCE_IRQ,
 826         },
 827 };
 828
 829 struct platform_device pxa3xx_device_mci2 = {
 830         .name           = "pxa2xx-mci",
 831         .id             = 1,
 832         .dev            = {
 833                 .dma_mask = &pxamci_dmamask,
 834                 .coherent_dma_mask =    0xffffffff,
 835         },
 836         .num_resources  = ARRAY_SIZE(pxa3xx_resources_mci2),
 837         .resource       = pxa3xx_resources_mci2,
 838 };
 839
 840 void __init pxa3xx_set_mci2_info(struct pxamci_platform_data *info)
 841 {
 842         pxa_register_device(&pxa3xx_device_mci2, info);
 843 }
 844
 845 static struct resource pxa3xx_resources_mci3[] = {
 846         [0] = {
 847                 .start  = 0x42500000,
 848                 .end    = 0x42500fff,
 849                 .flags  = IORESOURCE_MEM,
 850         },
 851         [1] = {
 852                 .start  = IRQ_MMC3,
 853                 .end    = IRQ_MMC3,
 854                 .flags  = IORESOURCE_IRQ,
 855         },
 856 };
 857
 858 struct platform_device pxa3xx_device_mci3 = {
 859         .name           = "pxa2xx-mci",
 860         .id             = 2,
 861         .dev            = {
 862                 .dma_mask = &pxamci_dmamask,
 863                 .coherent_dma_mask = 0xffffffff,
 864         },
 865         .num_resources  = ARRAY_SIZE(pxa3xx_resources_mci3),
 866         .resource       = pxa3xx_resources_mci3,
 867 };
 868
 869 void __init pxa3xx_set_mci3_info(struct pxamci_platform_data *info)
 870 {
 871         pxa_register_device(&pxa3xx_device_mci3, info);
 872 }
 873
 874 static struct resource pxa3xx_resources_gcu[] = {
 875         {
 876                 .start  = 0x54000000,
 877                 .end    = 0x54000fff,
 878                 .flags  = IORESOURCE_MEM,
 879         },
 880         {
 881                 .start  = IRQ_GCU,
 882                 .end    = IRQ_GCU,
 883                 .flags  = IORESOURCE_IRQ,
 884         },
 885 };
 886
 887 static u64 pxa3xx_gcu_dmamask = DMA_BIT_MASK(32);
 888
 889 struct platform_device pxa3xx_device_gcu = {
 890         .name           = "pxa3xx-gcu",
 891         .id             = -1,
 892         .num_resources  = ARRAY_SIZE(pxa3xx_resources_gcu),
 893         .resource       = pxa3xx_resources_gcu,
 894         .dev            = {
 895                 .dma_mask = &pxa3xx_gcu_dmamask,
 896                 .coherent_dma_mask = 0xffffffff,
 897         },
 898 };
 899
 900 #endif /* CONFIG_PXA3xx */
 901
 902 #if defined(CONFIG_PXA3xx)
 903 static struct resource pxa3xx_resources_i2c_power[] = {
 904         {
 905                 .start  = 0x40f500c0,
 906                 .end    = 0x40f500d3,
 907                 .flags  = IORESOURCE_MEM,
 908         }, {
 909                 .start  = IRQ_PWRI2C,
 910                 .end    = IRQ_PWRI2C,
 911                 .flags  = IORESOURCE_IRQ,
 912         },
 913 };
 914
 915 struct platform_device pxa3xx_device_i2c_power = {
 916         .name           = "pxa3xx-pwri2c",
 917         .id             = 1,
 918         .resource       = pxa3xx_resources_i2c_power,
 919         .num_resources  = ARRAY_SIZE(pxa3xx_resources_i2c_power),
 920 };
 921
 922 static struct resource pxa3xx_resources_nand[] = {
 923         [0] = {
 924                 .start  = 0x43100000,
 925                 .end    = 0x43100053,
 926                 .flags  = IORESOURCE_MEM,
 927         },
 928         [1] = {
 929                 .start  = IRQ_NAND,
 930                 .end    = IRQ_NAND,
 931                 .flags  = IORESOURCE_IRQ,
 932         },
 933 };
 934
 935 static u64 pxa3xx_nand_dma_mask = DMA_BIT_MASK(32);
 936
 937 struct platform_device pxa3xx_device_nand = {
 938         .name           = "pxa3xx-nand",
 939         .id             = -1,
 940         .dev            = {
 941                 .dma_mask = &pxa3xx_nand_dma_mask,
 942                 .coherent_dma_mask = DMA_BIT_MASK(32),
 943         },
 944         .num_resources  = ARRAY_SIZE(pxa3xx_resources_nand),
 945         .resource       = pxa3xx_resources_nand,
 946 };
 947
 948 void __init pxa3xx_set_nand_info(struct pxa3xx_nand_platform_data *info)
 949 {
 950         pxa_register_device(&pxa3xx_device_nand, info);
 951 }
 952
 953 static u64 pxa3xx_ssp4_dma_mask = DMA_BIT_MASK(32);
 954
 955 static struct resource pxa3xx_resource_ssp4[] = {
 956         [0] = {
 957                 .start  = 0x41a00000,
 958                 .end    = 0x41a0003f,
 959                 .flags  = IORESOURCE_MEM,
 960         },
 961         [1] = {
 962                 .start  = IRQ_SSP4,
 963                 .end    = IRQ_SSP4,
 964                 .flags  = IORESOURCE_IRQ,
 965         },
 966 };
 967
 968 /*
 969  * PXA3xx SSP is basically equivalent to PXA27x.
 970  * However, we need to register the device by the correct name in order to
 971  * make the driver set the correct internal type, hence we provide specific
 972  * platform_devices for each of them.
 973  */
 974 struct platform_device pxa3xx_device_ssp1 = {
 975         .name           = "pxa3xx-ssp",
 976         .id             = 0,
 977         .dev            = {
 978                 .dma_mask = &pxa27x_ssp1_dma_mask,
 979                 .coherent_dma_mask = DMA_BIT_MASK(32),
 980         },
 981         .resource       = pxa27x_resource_ssp1,
 982         .num_resources  = ARRAY_SIZE(pxa27x_resource_ssp1),
 983 };
 984
 985 struct platform_device pxa3xx_device_ssp2 = {
 986         .name           = "pxa3xx-ssp",
 987         .id             = 1,
 988         .dev            = {
 989                 .dma_mask = &pxa27x_ssp2_dma_mask,
 990                 .coherent_dma_mask = DMA_BIT_MASK(32),
 991         },
 992         .resource       = pxa27x_resource_ssp2,
 993         .num_resources  = ARRAY_SIZE(pxa27x_resource_ssp2),
 994 };
 995
 996 struct platform_device pxa3xx_device_ssp3 = {
 997         .name           = "pxa3xx-ssp",
 998         .id             = 2,
 999         .dev            = {
1000                 .dma_mask = &pxa27x_ssp3_dma_mask,
1001                 .coherent_dma_mask = DMA_BIT_MASK(32),
1002         },
1003         .resource       = pxa27x_resource_ssp3,
1004         .num_resources  = ARRAY_SIZE(pxa27x_resource_ssp3),
1005 };
1006
1007 struct platform_device pxa3xx_device_ssp4 = {
1008         .name           = "pxa3xx-ssp",
1009         .id             = 3,
1010         .dev            = {
1011                 .dma_mask = &pxa3xx_ssp4_dma_mask,
1012                 .coherent_dma_mask = DMA_BIT_MASK(32),
1013         },
1014         .resource       = pxa3xx_resource_ssp4,
1015         .num_resources  = ARRAY_SIZE(pxa3xx_resource_ssp4),
1016 };
1017 #endif /* CONFIG_PXA3xx */
1018
1019 struct resource pxa_resource_gpio[] = {
1020         {
1021                 .start  = 0x40e00000,
1022                 .end    = 0x40e0ffff,
1023                 .flags  = IORESOURCE_MEM,
1024         }, {
1025                 .start  = IRQ_GPIO0,
1026                 .end    = IRQ_GPIO0,
1027                 .name   = "gpio0",
1028                 .flags  = IORESOURCE_IRQ,
1029         }, {
1030                 .start  = IRQ_GPIO1,
1031                 .end    = IRQ_GPIO1,
1032                 .name   = "gpio1",
1033                 .flags  = IORESOURCE_IRQ,
1034         }, {
1035                 .start  = IRQ_GPIO_2_x,
1036                 .end    = IRQ_GPIO_2_x,
1037                 .name   = "gpio_mux",
1038                 .flags  = IORESOURCE_IRQ,
1039         },
1040 };
1041
1042 struct platform_device pxa25x_device_gpio = {
1043 #ifdef CONFIG_CPU_PXA26x
1044         .name           = "pxa26x-gpio",
1045 #else
1046         .name           = "pxa25x-gpio",
1047 #endif
1048         .id             = -1,
1049         .num_resources  = ARRAY_SIZE(pxa_resource_gpio),
1050         .resource       = pxa_resource_gpio,
1051 };
1052
1053 struct platform_device pxa27x_device_gpio = {
1054         .name           = "pxa27x-gpio",
1055         .id             = -1,
1056         .num_resources  = ARRAY_SIZE(pxa_resource_gpio),
1057         .resource       = pxa_resource_gpio,
1058 };
1059
1060 struct platform_device pxa3xx_device_gpio = {
1061         .name           = "pxa3xx-gpio",
1062         .id             = -1,
1063         .num_resources  = ARRAY_SIZE(pxa_resource_gpio),
1064         .resource       = pxa_resource_gpio,
1065 };
1066
1067 struct platform_device pxa93x_device_gpio = {
1068         .name           = "pxa93x-gpio",
1069         .id             = -1,
1070         .num_resources  = ARRAY_SIZE(pxa_resource_gpio),
1071         .resource       = pxa_resource_gpio,
1072 };
1073
1074 /* pxa2xx-spi platform-device ID equals respective SSP platform-device ID + 1.
1075  * See comment in arch/arm/mach-pxa/ssp.c::ssp_probe() */
1076 void __init pxa2xx_set_spi_info(unsigned id, struct pxa2xx_spi_controller *info)
1077 {
1078         struct platform_device *pd;
1079
1080         pd = platform_device_alloc("pxa2xx-spi", id);
1081         if (pd == NULL) {
1082                 printk(KERN_ERR "pxa2xx-spi: failed to allocate device id %d\n",
1083                        id);
1084                 return;
1085         }
1086
1087         pd->dev.platform_data = info;
1088         platform_device_add(pd);
1089 }
1090
1091 static struct resource pxa_dma_resource[] = {
1092         [0] = {
1093                 .start  = 0x40000000,
1094                 .end    = 0x4000ffff,
1095                 .flags  = IORESOURCE_MEM,
1096         },
1097         [1] = {
1098                 .start  = IRQ_DMA,
1099                 .end    = IRQ_DMA,
1100                 .flags  = IORESOURCE_IRQ,
1101         },
1102 };
1103
1104 static u64 pxadma_dmamask = 0xffffffffUL;
1105
1106 static struct platform_device pxa2xx_pxa_dma = {
1107         .name           = "pxa-dma",
1108         .id             = 0,
1109         .dev            = {
1110                 .dma_mask = &pxadma_dmamask,
1111                 .coherent_dma_mask = 0xffffffff,
1112         },
1113         .num_resources  = ARRAY_SIZE(pxa_dma_resource),
1114         .resource       = pxa_dma_resource,
1115 };
1116
1117 void __init pxa2xx_set_dmac_info(struct mmp_dma_platdata *dma_pdata)
1118 {
1119         pxa_register_device(&pxa2xx_pxa_dma, dma_pdata);
1120 }