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 #include <linux/soc/pxa/cpu.h>
  13
  14 #include "udc.h"
  15 #include <linux/platform_data/video-pxafb.h>
  16 #include <linux/platform_data/mmc-pxamci.h>
  17 #include "irqs.h"
  18 #include <linux/platform_data/usb-ohci-pxa27x.h>
  19 #include <linux/platform_data/mmp_dma.h>
  20
  21 #include "regs-ost.h"
  22 #include "reset.h"
  23 #include "devices.h"
  24 #include "generic.h"
  25
  26 void __init pxa_register_device(struct platform_device *dev, void *data)
  27 {
  28         int ret;
  29
  30         dev->dev.platform_data = data;
  31
  32         ret = platform_device_register(dev);
  33         if (ret)
  34                 dev_err(&dev->dev, "unable to register device: %d\n", ret);
  35 }
  36
  37 static struct resource pxa_resource_pmu = {
  38         .start  = IRQ_PMU,
  39         .end    = IRQ_PMU,
  40         .flags  = IORESOURCE_IRQ,
  41 };
  42
  43 struct platform_device pxa_device_pmu = {
  44         .name           = "xscale-pmu",
  45         .id             = -1,
  46         .resource       = &pxa_resource_pmu,
  47         .num_resources  = 1,
  48 };
  49
  50 static struct resource pxamci_resources[] = {
  51         [0] = {
  52                 .start  = 0x41100000,
  53                 .end    = 0x41100fff,
  54                 .flags  = IORESOURCE_MEM,
  55         },
  56         [1] = {
  57                 .start  = IRQ_MMC,
  58                 .end    = IRQ_MMC,
  59                 .flags  = IORESOURCE_IRQ,
  60         },
  61 };
  62
  63 static u64 pxamci_dmamask = 0xffffffffUL;
  64
  65 struct platform_device pxa_device_mci = {
  66         .name           = "pxa2xx-mci",
  67         .id             = 0,
  68         .dev            = {
  69                 .dma_mask = &pxamci_dmamask,
  70                 .coherent_dma_mask = 0xffffffff,
  71         },
  72         .num_resources  = ARRAY_SIZE(pxamci_resources),
  73         .resource       = pxamci_resources,
  74 };
  75
  76 void __init pxa_set_mci_info(struct pxamci_platform_data *info)
  77 {
  78         pxa_register_device(&pxa_device_mci, info);
  79 }
  80
  81 static struct pxa2xx_udc_mach_info pxa_udc_info = {
  82         .gpio_pullup = -1,
  83 };
  84
  85 static struct resource pxa2xx_udc_resources[] = {
  86         [0] = {
  87                 .start  = 0x40600000,
  88                 .end    = 0x4060ffff,
  89                 .flags  = IORESOURCE_MEM,
  90         },
  91         [1] = {
  92                 .start  = IRQ_USB,
  93                 .end    = IRQ_USB,
  94                 .flags  = IORESOURCE_IRQ,
  95         },
  96 };
  97
  98 static u64 udc_dma_mask = ~(u32)0;
  99
 100 struct platform_device pxa25x_device_udc = {
 101         .name           = "pxa25x-udc",
 102         .id             = -1,
 103         .resource       = pxa2xx_udc_resources,
 104         .num_resources  = ARRAY_SIZE(pxa2xx_udc_resources),
 105         .dev            =  {
 106                 .platform_data  = &pxa_udc_info,
 107                 .dma_mask       = &udc_dma_mask,
 108         }
 109 };
 110
 111 struct platform_device pxa27x_device_udc = {
 112         .name           = "pxa27x-udc",
 113         .id             = -1,
 114         .resource       = pxa2xx_udc_resources,
 115         .num_resources  = ARRAY_SIZE(pxa2xx_udc_resources),
 116         .dev            =  {
 117                 .platform_data  = &pxa_udc_info,
 118                 .dma_mask       = &udc_dma_mask,
 119         }
 120 };
 121
 122 static struct resource pxafb_resources[] = {
 123         [0] = {
 124                 .start  = 0x44000000,
 125                 .end    = 0x4400ffff,
 126                 .flags  = IORESOURCE_MEM,
 127         },
 128         [1] = {
 129                 .start  = IRQ_LCD,
 130                 .end    = IRQ_LCD,
 131                 .flags  = IORESOURCE_IRQ,
 132         },
 133 };
 134
 135 static u64 fb_dma_mask = ~(u64)0;
 136
 137 struct platform_device pxa_device_fb = {
 138         .name           = "pxa2xx-fb",
 139         .id             = -1,
 140         .dev            = {
 141                 .dma_mask       = &fb_dma_mask,
 142                 .coherent_dma_mask = 0xffffffff,
 143         },
 144         .num_resources  = ARRAY_SIZE(pxafb_resources),
 145         .resource       = pxafb_resources,
 146 };
 147
 148 void __init pxa_set_fb_info(struct device *parent, struct pxafb_mach_info *info)
 149 {
 150         pxa_device_fb.dev.parent = parent;
 151         pxa_register_device(&pxa_device_fb, info);
 152 }
 153
 154 static struct resource pxa_resource_ffuart[] = {
 155         {
 156                 .start  = 0x40100000,
 157                 .end    = 0x40100023,
 158                 .flags  = IORESOURCE_MEM,
 159         }, {
 160                 .start  = IRQ_FFUART,
 161                 .end    = IRQ_FFUART,
 162                 .flags  = IORESOURCE_IRQ,
 163         }
 164 };
 165
 166 struct platform_device pxa_device_ffuart = {
 167         .name           = "pxa2xx-uart",
 168         .id             = 0,
 169         .resource       = pxa_resource_ffuart,
 170         .num_resources  = ARRAY_SIZE(pxa_resource_ffuart),
 171 };
 172
 173 void __init pxa_set_ffuart_info(void *info)
 174 {
 175         pxa_register_device(&pxa_device_ffuart, info);
 176 }
 177
 178 static struct resource pxa_resource_btuart[] = {
 179         {
 180                 .start  = 0x40200000,
 181                 .end    = 0x40200023,
 182                 .flags  = IORESOURCE_MEM,
 183         }, {
 184                 .start  = IRQ_BTUART,
 185                 .end    = IRQ_BTUART,
 186                 .flags  = IORESOURCE_IRQ,
 187         }
 188 };
 189
 190 struct platform_device pxa_device_btuart = {
 191         .name           = "pxa2xx-uart",
 192         .id             = 1,
 193         .resource       = pxa_resource_btuart,
 194         .num_resources  = ARRAY_SIZE(pxa_resource_btuart),
 195 };
 196
 197 void __init pxa_set_btuart_info(void *info)
 198 {
 199         pxa_register_device(&pxa_device_btuart, info);
 200 }
 201
 202 static struct resource pxa_resource_stuart[] = {
 203         {
 204                 .start  = 0x40700000,
 205                 .end    = 0x40700023,
 206                 .flags  = IORESOURCE_MEM,
 207         }, {
 208                 .start  = IRQ_STUART,
 209                 .end    = IRQ_STUART,
 210                 .flags  = IORESOURCE_IRQ,
 211         }
 212 };
 213
 214 struct platform_device pxa_device_stuart = {
 215         .name           = "pxa2xx-uart",
 216         .id             = 2,
 217         .resource       = pxa_resource_stuart,
 218         .num_resources  = ARRAY_SIZE(pxa_resource_stuart),
 219 };
 220
 221 void __init pxa_set_stuart_info(void *info)
 222 {
 223         pxa_register_device(&pxa_device_stuart, info);
 224 }
 225
 226 static struct resource pxa_resource_hwuart[] = {
 227         {
 228                 .start  = 0x41600000,
 229                 .end    = 0x4160002F,
 230                 .flags  = IORESOURCE_MEM,
 231         }, {
 232                 .start  = IRQ_HWUART,
 233                 .end    = IRQ_HWUART,
 234                 .flags  = IORESOURCE_IRQ,
 235         }
 236 };
 237
 238 struct platform_device pxa_device_hwuart = {
 239         .name           = "pxa2xx-uart",
 240         .id             = 3,
 241         .resource       = pxa_resource_hwuart,
 242         .num_resources  = ARRAY_SIZE(pxa_resource_hwuart),
 243 };
 244
 245 void __init pxa_set_hwuart_info(void *info)
 246 {
 247         if (cpu_is_pxa255())
 248                 pxa_register_device(&pxa_device_hwuart, info);
 249         else
 250                 pr_info("UART: Ignoring attempt to register HWUART on non-PXA255 hardware");
 251 }
 252
 253 static struct resource pxai2c_resources[] = {
 254         {
 255                 .start  = 0x40301680,
 256                 .end    = 0x403016a3,
 257                 .flags  = IORESOURCE_MEM,
 258         }, {
 259                 .start  = IRQ_I2C,
 260                 .end    = IRQ_I2C,
 261                 .flags  = IORESOURCE_IRQ,
 262         },
 263 };
 264
 265 struct platform_device pxa_device_i2c = {
 266         .name           = "pxa2xx-i2c",
 267         .id             = 0,
 268         .resource       = pxai2c_resources,
 269         .num_resources  = ARRAY_SIZE(pxai2c_resources),
 270 };
 271
 272 void __init pxa_set_i2c_info(struct i2c_pxa_platform_data *info)
 273 {
 274         pxa_register_device(&pxa_device_i2c, info);
 275 }
 276
 277 #ifdef CONFIG_PXA27x
 278 static struct resource pxa27x_resources_i2c_power[] = {
 279         {
 280                 .start  = 0x40f00180,
 281                 .end    = 0x40f001a3,
 282                 .flags  = IORESOURCE_MEM,
 283         }, {
 284                 .start  = IRQ_PWRI2C,
 285                 .end    = IRQ_PWRI2C,
 286                 .flags  = IORESOURCE_IRQ,
 287         },
 288 };
 289
 290 struct platform_device pxa27x_device_i2c_power = {
 291         .name           = "pxa2xx-i2c",
 292         .id             = 1,
 293         .resource       = pxa27x_resources_i2c_power,
 294         .num_resources  = ARRAY_SIZE(pxa27x_resources_i2c_power),
 295 };
 296 #endif
 297
 298 static struct resource pxai2s_resources[] = {
 299         {
 300                 .start  = 0x40400000,
 301                 .end    = 0x40400083,
 302                 .flags  = IORESOURCE_MEM,
 303         }, {
 304                 .start  = IRQ_I2S,
 305                 .end    = IRQ_I2S,
 306                 .flags  = IORESOURCE_IRQ,
 307         },
 308 };
 309
 310 struct platform_device pxa_device_i2s = {
 311         .name           = "pxa2xx-i2s",
 312         .id             = -1,
 313         .resource       = pxai2s_resources,
 314         .num_resources  = ARRAY_SIZE(pxai2s_resources),
 315 };
 316
 317 struct platform_device pxa_device_asoc_ssp1 = {
 318         .name           = "pxa-ssp-dai",
 319         .id             = 0,
 320 };
 321
 322 struct platform_device pxa_device_asoc_ssp2= {
 323         .name           = "pxa-ssp-dai",
 324         .id             = 1,
 325 };
 326
 327 struct platform_device pxa_device_asoc_ssp3 = {
 328         .name           = "pxa-ssp-dai",
 329         .id             = 2,
 330 };
 331
 332 struct platform_device pxa_device_asoc_ssp4 = {
 333         .name           = "pxa-ssp-dai",
 334         .id             = 3,
 335 };
 336
 337 struct platform_device pxa_device_asoc_platform = {
 338         .name           = "pxa-pcm-audio",
 339         .id             = -1,
 340 };
 341
 342 static struct resource pxa_rtc_resources[] = {
 343         [0] = {
 344                 .start  = 0x40900000,
 345                 .end    = 0x40900000 + 0x3b,
 346                 .flags  = IORESOURCE_MEM,
 347         },
 348         [1] = {
 349                 .start  = IRQ_RTC1Hz,
 350                 .end    = IRQ_RTC1Hz,
 351                 .name   = "rtc 1Hz",
 352                 .flags  = IORESOURCE_IRQ,
 353         },
 354         [2] = {
 355                 .start  = IRQ_RTCAlrm,
 356                 .end    = IRQ_RTCAlrm,
 357                 .name   = "rtc alarm",
 358                 .flags  = IORESOURCE_IRQ,
 359         },
 360 };
 361
 362 struct platform_device pxa_device_rtc = {
 363         .name           = "pxa-rtc",
 364         .id             = -1,
 365         .num_resources  = ARRAY_SIZE(pxa_rtc_resources),
 366         .resource       = pxa_rtc_resources,
 367 };
 368
 369 struct platform_device sa1100_device_rtc = {
 370         .name           = "sa1100-rtc",
 371         .id             = -1,
 372         .num_resources  = ARRAY_SIZE(pxa_rtc_resources),
 373         .resource       = pxa_rtc_resources,
 374 };
 375
 376 #ifdef CONFIG_PXA25x
 377
 378 static struct resource pxa25x_resource_pwm0[] = {
 379         [0] = {
 380                 .start  = 0x40b00000,
 381                 .end    = 0x40b0000f,
 382                 .flags  = IORESOURCE_MEM,
 383         },
 384 };
 385
 386 struct platform_device pxa25x_device_pwm0 = {
 387         .name           = "pxa25x-pwm",
 388         .id             = 0,
 389         .resource       = pxa25x_resource_pwm0,
 390         .num_resources  = ARRAY_SIZE(pxa25x_resource_pwm0),
 391 };
 392
 393 static struct resource pxa25x_resource_pwm1[] = {
 394         [0] = {
 395                 .start  = 0x40c00000,
 396                 .end    = 0x40c0000f,
 397                 .flags  = IORESOURCE_MEM,
 398         },
 399 };
 400
 401 struct platform_device pxa25x_device_pwm1 = {
 402         .name           = "pxa25x-pwm",
 403         .id             = 1,
 404         .resource       = pxa25x_resource_pwm1,
 405         .num_resources  = ARRAY_SIZE(pxa25x_resource_pwm1),
 406 };
 407
 408 static u64 pxa25x_ssp_dma_mask = DMA_BIT_MASK(32);
 409
 410 static struct resource pxa25x_resource_ssp[] = {
 411         [0] = {
 412                 .start  = 0x41000000,
 413                 .end    = 0x4100001f,
 414                 .flags  = IORESOURCE_MEM,
 415         },
 416         [1] = {
 417                 .start  = IRQ_SSP,
 418                 .end    = IRQ_SSP,
 419                 .flags  = IORESOURCE_IRQ,
 420         },
 421 };
 422
 423 struct platform_device pxa25x_device_ssp = {
 424         .name           = "pxa25x-ssp",
 425         .id             = 0,
 426         .dev            = {
 427                 .dma_mask = &pxa25x_ssp_dma_mask,
 428                 .coherent_dma_mask = DMA_BIT_MASK(32),
 429         },
 430         .resource       = pxa25x_resource_ssp,
 431         .num_resources  = ARRAY_SIZE(pxa25x_resource_ssp),
 432 };
 433
 434 static u64 pxa25x_nssp_dma_mask = DMA_BIT_MASK(32);
 435
 436 static struct resource pxa25x_resource_nssp[] = {
 437         [0] = {
 438                 .start  = 0x41400000,
 439                 .end    = 0x4140002f,
 440                 .flags  = IORESOURCE_MEM,
 441         },
 442         [1] = {
 443                 .start  = IRQ_NSSP,
 444                 .end    = IRQ_NSSP,
 445                 .flags  = IORESOURCE_IRQ,
 446         },
 447 };
 448
 449 struct platform_device pxa25x_device_nssp = {
 450         .name           = "pxa25x-nssp",
 451         .id             = 1,
 452         .dev            = {
 453                 .dma_mask = &pxa25x_nssp_dma_mask,
 454                 .coherent_dma_mask = DMA_BIT_MASK(32),
 455         },
 456         .resource       = pxa25x_resource_nssp,
 457         .num_resources  = ARRAY_SIZE(pxa25x_resource_nssp),
 458 };
 459
 460 static u64 pxa25x_assp_dma_mask = DMA_BIT_MASK(32);
 461
 462 static struct resource pxa25x_resource_assp[] = {
 463         [0] = {
 464                 .start  = 0x41500000,
 465                 .end    = 0x4150002f,
 466                 .flags  = IORESOURCE_MEM,
 467         },
 468         [1] = {
 469                 .start  = IRQ_ASSP,
 470                 .end    = IRQ_ASSP,
 471                 .flags  = IORESOURCE_IRQ,
 472         },
 473 };
 474
 475 struct platform_device pxa25x_device_assp = {
 476         /* ASSP is basically equivalent to NSSP */
 477         .name           = "pxa25x-nssp",
 478         .id             = 2,
 479         .dev            = {
 480                 .dma_mask = &pxa25x_assp_dma_mask,
 481                 .coherent_dma_mask = DMA_BIT_MASK(32),
 482         },
 483         .resource       = pxa25x_resource_assp,
 484         .num_resources  = ARRAY_SIZE(pxa25x_resource_assp),
 485 };
 486 #endif /* CONFIG_PXA25x */
 487
 488 #if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
 489 static u64 pxa27x_ohci_dma_mask = DMA_BIT_MASK(32);
 490
 491 static struct resource pxa27x_resource_ohci[] = {
 492         [0] = {
 493                 .start  = 0x4C000000,
 494                 .end    = 0x4C00ff6f,
 495                 .flags  = IORESOURCE_MEM,
 496         },
 497         [1] = {
 498                 .start  = IRQ_USBH1,
 499                 .end    = IRQ_USBH1,
 500                 .flags  = IORESOURCE_IRQ,
 501         },
 502 };
 503
 504 struct platform_device pxa27x_device_ohci = {
 505         .name           = "pxa27x-ohci",
 506         .id             = -1,
 507         .dev            = {
 508                 .dma_mask = &pxa27x_ohci_dma_mask,
 509                 .coherent_dma_mask = DMA_BIT_MASK(32),
 510         },
 511         .num_resources  = ARRAY_SIZE(pxa27x_resource_ohci),
 512         .resource       = pxa27x_resource_ohci,
 513 };
 514
 515 void __init pxa_set_ohci_info(struct pxaohci_platform_data *info)
 516 {
 517         pxa_register_device(&pxa27x_device_ohci, info);
 518 }
 519 #endif /* CONFIG_PXA27x || CONFIG_PXA3xx */
 520
 521 #if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
 522 static u64 pxa27x_ssp1_dma_mask = DMA_BIT_MASK(32);
 523
 524 static struct resource pxa27x_resource_ssp1[] = {
 525         [0] = {
 526                 .start  = 0x41000000,
 527                 .end    = 0x4100003f,
 528                 .flags  = IORESOURCE_MEM,
 529         },
 530         [1] = {
 531                 .start  = IRQ_SSP,
 532                 .end    = IRQ_SSP,
 533                 .flags  = IORESOURCE_IRQ,
 534         },
 535 };
 536
 537 struct platform_device pxa27x_device_ssp1 = {
 538         .name           = "pxa27x-ssp",
 539         .id             = 0,
 540         .dev            = {
 541                 .dma_mask = &pxa27x_ssp1_dma_mask,
 542                 .coherent_dma_mask = DMA_BIT_MASK(32),
 543         },
 544         .resource       = pxa27x_resource_ssp1,
 545         .num_resources  = ARRAY_SIZE(pxa27x_resource_ssp1),
 546 };
 547
 548 static u64 pxa27x_ssp2_dma_mask = DMA_BIT_MASK(32);
 549
 550 static struct resource pxa27x_resource_ssp2[] = {
 551         [0] = {
 552                 .start  = 0x41700000,
 553                 .end    = 0x4170003f,
 554                 .flags  = IORESOURCE_MEM,
 555         },
 556         [1] = {
 557                 .start  = IRQ_SSP2,
 558                 .end    = IRQ_SSP2,
 559                 .flags  = IORESOURCE_IRQ,
 560         },
 561 };
 562
 563 struct platform_device pxa27x_device_ssp2 = {
 564         .name           = "pxa27x-ssp",
 565         .id             = 1,
 566         .dev            = {
 567                 .dma_mask = &pxa27x_ssp2_dma_mask,
 568                 .coherent_dma_mask = DMA_BIT_MASK(32),
 569         },
 570         .resource       = pxa27x_resource_ssp2,
 571         .num_resources  = ARRAY_SIZE(pxa27x_resource_ssp2),
 572 };
 573
 574 static u64 pxa27x_ssp3_dma_mask = DMA_BIT_MASK(32);
 575
 576 static struct resource pxa27x_resource_ssp3[] = {
 577         [0] = {
 578                 .start  = 0x41900000,
 579                 .end    = 0x4190003f,
 580                 .flags  = IORESOURCE_MEM,
 581         },
 582         [1] = {
 583                 .start  = IRQ_SSP3,
 584                 .end    = IRQ_SSP3,
 585                 .flags  = IORESOURCE_IRQ,
 586         },
 587 };
 588
 589 struct platform_device pxa27x_device_ssp3 = {
 590         .name           = "pxa27x-ssp",
 591         .id             = 2,
 592         .dev            = {
 593                 .dma_mask = &pxa27x_ssp3_dma_mask,
 594                 .coherent_dma_mask = DMA_BIT_MASK(32),
 595         },
 596         .resource       = pxa27x_resource_ssp3,
 597         .num_resources  = ARRAY_SIZE(pxa27x_resource_ssp3),
 598 };
 599
 600 static struct resource pxa27x_resource_pwm0[] = {
 601         [0] = {
 602                 .start  = 0x40b00000,
 603                 .end    = 0x40b0001f,
 604                 .flags  = IORESOURCE_MEM,
 605         },
 606 };
 607
 608 struct platform_device pxa27x_device_pwm0 = {
 609         .name           = "pxa27x-pwm",
 610         .id             = 0,
 611         .resource       = pxa27x_resource_pwm0,
 612         .num_resources  = ARRAY_SIZE(pxa27x_resource_pwm0),
 613 };
 614
 615 static struct resource pxa27x_resource_pwm1[] = {
 616         [0] = {
 617                 .start  = 0x40c00000,
 618                 .end    = 0x40c0001f,
 619                 .flags  = IORESOURCE_MEM,
 620         },
 621 };
 622
 623 struct platform_device pxa27x_device_pwm1 = {
 624         .name           = "pxa27x-pwm",
 625         .id             = 1,
 626         .resource       = pxa27x_resource_pwm1,
 627         .num_resources  = ARRAY_SIZE(pxa27x_resource_pwm1),
 628 };
 629 #endif /* CONFIG_PXA27x || CONFIG_PXA3xx */
 630
 631 struct resource pxa_resource_gpio[] = {
 632         {
 633                 .start  = 0x40e00000,
 634                 .end    = 0x40e0ffff,
 635                 .flags  = IORESOURCE_MEM,
 636         }, {
 637                 .start  = IRQ_GPIO0,
 638                 .end    = IRQ_GPIO0,
 639                 .name   = "gpio0",
 640                 .flags  = IORESOURCE_IRQ,
 641         }, {
 642                 .start  = IRQ_GPIO1,
 643                 .end    = IRQ_GPIO1,
 644                 .name   = "gpio1",
 645                 .flags  = IORESOURCE_IRQ,
 646         }, {
 647                 .start  = IRQ_GPIO_2_x,
 648                 .end    = IRQ_GPIO_2_x,
 649                 .name   = "gpio_mux",
 650                 .flags  = IORESOURCE_IRQ,
 651         },
 652 };
 653
 654 struct platform_device pxa25x_device_gpio = {
 655         .name           = "pxa25x-gpio",
 656         .id             = -1,
 657         .num_resources  = ARRAY_SIZE(pxa_resource_gpio),
 658         .resource       = pxa_resource_gpio,
 659 };
 660
 661 struct platform_device pxa27x_device_gpio = {
 662         .name           = "pxa27x-gpio",
 663         .id             = -1,
 664         .num_resources  = ARRAY_SIZE(pxa_resource_gpio),
 665         .resource       = pxa_resource_gpio,
 666 };
 667
 668 /* pxa2xx-spi platform-device ID equals respective SSP platform-device ID + 1.
 669  * See comment in arch/arm/mach-pxa/ssp.c::ssp_probe() */
 670 void __init pxa2xx_set_spi_info(unsigned id, struct pxa2xx_spi_controller *info)
 671 {
 672         struct platform_device *pd;
 673
 674         pd = platform_device_alloc("pxa2xx-spi", id);
 675         if (pd == NULL) {
 676                 printk(KERN_ERR "pxa2xx-spi: failed to allocate device id %d\n",
 677                        id);
 678                 return;
 679         }
 680
 681         pd->dev.platform_data = info;
 682         platform_device_add(pd);
 683 }
 684
 685 static struct resource pxa_dma_resource[] = {
 686         [0] = {
 687                 .start  = 0x40000000,
 688                 .end    = 0x4000ffff,
 689                 .flags  = IORESOURCE_MEM,
 690         },
 691         [1] = {
 692                 .start  = IRQ_DMA,
 693                 .end    = IRQ_DMA,
 694                 .flags  = IORESOURCE_IRQ,
 695         },
 696 };
 697
 698 static u64 pxadma_dmamask = 0xffffffffUL;
 699
 700 static struct platform_device pxa2xx_pxa_dma = {
 701         .name           = "pxa-dma",
 702         .id             = 0,
 703         .dev            = {
 704                 .dma_mask = &pxadma_dmamask,
 705                 .coherent_dma_mask = 0xffffffff,
 706         },
 707         .num_resources  = ARRAY_SIZE(pxa_dma_resource),
 708         .resource       = pxa_dma_resource,
 709 };
 710
 711 void __init pxa2xx_set_dmac_info(struct mmp_dma_platdata *dma_pdata)
 712 {
 713         pxa_register_device(&pxa2xx_pxa_dma, dma_pdata);
 714 }
 715
 716 void __init pxa_register_wdt(unsigned int reset_status)
 717 {
 718         struct resource res = DEFINE_RES_MEM(OST_PHYS, OST_LEN);
 719
 720         reset_status &= RESET_STATUS_WATCHDOG;
 721         platform_device_register_resndata(NULL, "sa1100_wdt", -1, &res, 1,
 722                                           &reset_status, sizeof(reset_status));
 723 }