arch/arm/mach-pxa/devices.c

   1 #include <linux/module.h>
   2 #include <linux/kernel.h>
   3 #include <linux/init.h>
   4 #include <linux/platform_device.h>
   5 #include <linux/dma-mapping.h>
   6
   7 #include <asm/arch/gpio.h>
   8 #include <asm/arch/udc.h>
   9 #include <asm/arch/pxafb.h>
  10 #include <asm/arch/mmc.h>
  11 #include <asm/arch/irda.h>
  12 #include <asm/arch/i2c.h>
  13 #include <asm/arch/mfp-pxa27x.h>
  14 #include <asm/arch/ohci.h>
  15 #include <asm/arch/pxa27x_keypad.h>
  16 #include <asm/arch/camera.h>
  17 #include <asm/arch/audio.h>
  18
  19 #include "devices.h"
  20 #include "generic.h"
  21
  22 void __init pxa_register_device(struct platform_device *dev, void *data)
  23 {
  24         int ret;
  25
  26         dev->dev.platform_data = data;
  27
  28         ret = platform_device_register(dev);
  29         if (ret)
  30                 dev_err(&dev->dev, "unable to register device: %d\n", ret);
  31 }
  32
  33 static struct resource pxamci_resources[] = {
  34         [0] = {
  35                 .start  = 0x41100000,
  36                 .end    = 0x41100fff,
  37                 .flags  = IORESOURCE_MEM,
  38         },
  39         [1] = {
  40                 .start  = IRQ_MMC,
  41                 .end    = IRQ_MMC,
  42                 .flags  = IORESOURCE_IRQ,
  43         },
  44         [2] = {
  45                 .start  = 21,
  46                 .end    = 21,
  47                 .flags  = IORESOURCE_DMA,
  48         },
  49         [3] = {
  50                 .start  = 22,
  51                 .end    = 22,
  52                 .flags  = IORESOURCE_DMA,
  53         },
  54 };
  55
  56 static u64 pxamci_dmamask = 0xffffffffUL;
  57
  58 struct platform_device pxa_device_mci = {
  59         .name           = "pxa2xx-mci",
  60         .id             = 0,
  61         .dev            = {
  62                 .dma_mask = &pxamci_dmamask,
  63                 .coherent_dma_mask = 0xffffffff,
  64         },
  65         .num_resources  = ARRAY_SIZE(pxamci_resources),
  66         .resource       = pxamci_resources,
  67 };
  68
  69 void __init pxa_set_mci_info(struct pxamci_platform_data *info)
  70 {
  71         pxa_register_device(&pxa_device_mci, info);
  72 }
  73
  74
  75 static struct pxa2xx_udc_mach_info pxa_udc_info;
  76
  77 void __init pxa_set_udc_info(struct pxa2xx_udc_mach_info *info)
  78 {
  79         memcpy(&pxa_udc_info, info, sizeof *info);
  80 }
  81
  82 static struct resource pxa2xx_udc_resources[] = {
  83         [0] = {
  84                 .start  = 0x40600000,
  85                 .end    = 0x4060ffff,
  86                 .flags  = IORESOURCE_MEM,
  87         },
  88         [1] = {
  89                 .start  = IRQ_USB,
  90                 .end    = IRQ_USB,
  91                 .flags  = IORESOURCE_IRQ,
  92         },
  93 };
  94
  95 static u64 udc_dma_mask = ~(u32)0;
  96
  97 struct platform_device pxa25x_device_udc = {
  98         .name           = "pxa25x-udc",
  99         .id             = -1,
 100         .resource       = pxa2xx_udc_resources,
 101         .num_resources  = ARRAY_SIZE(pxa2xx_udc_resources),
 102         .dev            =  {
 103                 .platform_data  = &pxa_udc_info,
 104                 .dma_mask       = &udc_dma_mask,
 105         }
 106 };
 107
 108 struct platform_device pxa27x_device_udc = {
 109         .name           = "pxa27x-udc",
 110         .id             = -1,
 111         .resource       = pxa2xx_udc_resources,
 112         .num_resources  = ARRAY_SIZE(pxa2xx_udc_resources),
 113         .dev            =  {
 114                 .platform_data  = &pxa_udc_info,
 115                 .dma_mask       = &udc_dma_mask,
 116         }
 117 };
 118
 119 static struct resource pxafb_resources[] = {
 120         [0] = {
 121                 .start  = 0x44000000,
 122                 .end    = 0x4400ffff,
 123                 .flags  = IORESOURCE_MEM,
 124         },
 125         [1] = {
 126                 .start  = IRQ_LCD,
 127                 .end    = IRQ_LCD,
 128                 .flags  = IORESOURCE_IRQ,
 129         },
 130 };
 131
 132 static u64 fb_dma_mask = ~(u64)0;
 133
 134 struct platform_device pxa_device_fb = {
 135         .name           = "pxa2xx-fb",
 136         .id             = -1,
 137         .dev            = {
 138                 .dma_mask       = &fb_dma_mask,
 139                 .coherent_dma_mask = 0xffffffff,
 140         },
 141         .num_resources  = ARRAY_SIZE(pxafb_resources),
 142         .resource       = pxafb_resources,
 143 };
 144
 145 void __init set_pxa_fb_info(struct pxafb_mach_info *info)
 146 {
 147         pxa_register_device(&pxa_device_fb, info);
 148 }
 149
 150 void __init set_pxa_fb_parent(struct device *parent_dev)
 151 {
 152         pxa_device_fb.dev.parent = parent_dev;
 153 }
 154
 155 static struct resource pxa_resource_ffuart[] = {
 156         {
 157                 .start  = __PREG(FFUART),
 158                 .end    = __PREG(FFUART) + 35,
 159                 .flags  = IORESOURCE_MEM,
 160         }, {
 161                 .start  = IRQ_FFUART,
 162                 .end    = IRQ_FFUART,
 163                 .flags  = IORESOURCE_IRQ,
 164         }
 165 };
 166
 167 struct platform_device pxa_device_ffuart= {
 168         .name           = "pxa2xx-uart",
 169         .id             = 0,
 170         .resource       = pxa_resource_ffuart,
 171         .num_resources  = ARRAY_SIZE(pxa_resource_ffuart),
 172 };
 173
 174 static struct resource pxa_resource_btuart[] = {
 175         {
 176                 .start  = __PREG(BTUART),
 177                 .end    = __PREG(BTUART) + 35,
 178                 .flags  = IORESOURCE_MEM,
 179         }, {
 180                 .start  = IRQ_BTUART,
 181                 .end    = IRQ_BTUART,
 182                 .flags  = IORESOURCE_IRQ,
 183         }
 184 };
 185
 186 struct platform_device pxa_device_btuart = {
 187         .name           = "pxa2xx-uart",
 188         .id             = 1,
 189         .resource       = pxa_resource_btuart,
 190         .num_resources  = ARRAY_SIZE(pxa_resource_btuart),
 191 };
 192
 193 static struct resource pxa_resource_stuart[] = {
 194         {
 195                 .start  = __PREG(STUART),
 196                 .end    = __PREG(STUART) + 35,
 197                 .flags  = IORESOURCE_MEM,
 198         }, {
 199                 .start  = IRQ_STUART,
 200                 .end    = IRQ_STUART,
 201                 .flags  = IORESOURCE_IRQ,
 202         }
 203 };
 204
 205 struct platform_device pxa_device_stuart = {
 206         .name           = "pxa2xx-uart",
 207         .id             = 2,
 208         .resource       = pxa_resource_stuart,
 209         .num_resources  = ARRAY_SIZE(pxa_resource_stuart),
 210 };
 211
 212 static struct resource pxa_resource_hwuart[] = {
 213         {
 214                 .start  = __PREG(HWUART),
 215                 .end    = __PREG(HWUART) + 47,
 216                 .flags  = IORESOURCE_MEM,
 217         }, {
 218                 .start  = IRQ_HWUART,
 219                 .end    = IRQ_HWUART,
 220                 .flags  = IORESOURCE_IRQ,
 221         }
 222 };
 223
 224 struct platform_device pxa_device_hwuart = {
 225         .name           = "pxa2xx-uart",
 226         .id             = 3,
 227         .resource       = pxa_resource_hwuart,
 228         .num_resources  = ARRAY_SIZE(pxa_resource_hwuart),
 229 };
 230
 231 static struct resource pxai2c_resources[] = {
 232         {
 233                 .start  = 0x40301680,
 234                 .end    = 0x403016a3,
 235                 .flags  = IORESOURCE_MEM,
 236         }, {
 237                 .start  = IRQ_I2C,
 238                 .end    = IRQ_I2C,
 239                 .flags  = IORESOURCE_IRQ,
 240         },
 241 };
 242
 243 struct platform_device pxa_device_i2c = {
 244         .name           = "pxa2xx-i2c",
 245         .id             = 0,
 246         .resource       = pxai2c_resources,
 247         .num_resources  = ARRAY_SIZE(pxai2c_resources),
 248 };
 249
 250 static unsigned long pxa27x_i2c_mfp_cfg[] = {
 251         GPIO117_I2C_SCL,
 252         GPIO118_I2C_SDA,
 253 };
 254
 255 void __init pxa_set_i2c_info(struct i2c_pxa_platform_data *info)
 256 {
 257         if (cpu_is_pxa27x())
 258                 pxa2xx_mfp_config(ARRAY_AND_SIZE(pxa27x_i2c_mfp_cfg));
 259         pxa_register_device(&pxa_device_i2c, info);
 260 }
 261
 262 static struct resource pxai2s_resources[] = {
 263         {
 264                 .start  = 0x40400000,
 265                 .end    = 0x40400083,
 266                 .flags  = IORESOURCE_MEM,
 267         }, {
 268                 .start  = IRQ_I2S,
 269                 .end    = IRQ_I2S,
 270                 .flags  = IORESOURCE_IRQ,
 271         },
 272 };
 273
 274 struct platform_device pxa_device_i2s = {
 275         .name           = "pxa2xx-i2s",
 276         .id             = -1,
 277         .resource       = pxai2s_resources,
 278         .num_resources  = ARRAY_SIZE(pxai2s_resources),
 279 };
 280
 281 static u64 pxaficp_dmamask = ~(u32)0;
 282
 283 struct platform_device pxa_device_ficp = {
 284         .name           = "pxa2xx-ir",
 285         .id             = -1,
 286         .dev            = {
 287                 .dma_mask = &pxaficp_dmamask,
 288                 .coherent_dma_mask = 0xffffffff,
 289         },
 290 };
 291
 292 void __init pxa_set_ficp_info(struct pxaficp_platform_data *info)
 293 {
 294         pxa_register_device(&pxa_device_ficp, info);
 295 }
 296
 297 struct platform_device pxa_device_rtc = {
 298         .name           = "sa1100-rtc",
 299         .id             = -1,
 300 };
 301
 302 static struct resource pxa_ac97_resources[] = {
 303         [0] = {
 304                 .start  = 0x40500000,
 305                 .end    = 0x40500000 + 0xfff,
 306                 .flags  = IORESOURCE_MEM,
 307         },
 308         [1] = {
 309                 .start  = IRQ_AC97,
 310                 .end    = IRQ_AC97,
 311                 .flags  = IORESOURCE_IRQ,
 312         },
 313 };
 314
 315 static u64 pxa_ac97_dmamask = 0xffffffffUL;
 316
 317 struct platform_device pxa_device_ac97 = {
 318         .name           = "pxa2xx-ac97",
 319         .id             = -1,
 320         .dev            = {
 321                 .dma_mask = &pxa_ac97_dmamask,
 322                 .coherent_dma_mask = 0xffffffff,
 323         },
 324         .num_resources  = ARRAY_SIZE(pxa_ac97_resources),
 325         .resource       = pxa_ac97_resources,
 326 };
 327
 328 void __init pxa_set_ac97_info(pxa2xx_audio_ops_t *ops)
 329 {
 330         pxa_register_device(&pxa_device_ac97, ops);
 331 }
 332
 333 #ifdef CONFIG_PXA25x
 334
 335 static struct resource pxa25x_resource_pwm0[] = {
 336         [0] = {
 337                 .start  = 0x40b00000,
 338                 .end    = 0x40b0000f,
 339                 .flags  = IORESOURCE_MEM,
 340         },
 341 };
 342
 343 struct platform_device pxa25x_device_pwm0 = {
 344         .name           = "pxa25x-pwm",
 345         .id             = 0,
 346         .resource       = pxa25x_resource_pwm0,
 347         .num_resources  = ARRAY_SIZE(pxa25x_resource_pwm0),
 348 };
 349
 350 static struct resource pxa25x_resource_pwm1[] = {
 351         [0] = {
 352                 .start  = 0x40c00000,
 353                 .end    = 0x40c0000f,
 354                 .flags  = IORESOURCE_MEM,
 355         },
 356 };
 357
 358 struct platform_device pxa25x_device_pwm1 = {
 359         .name           = "pxa25x-pwm",
 360         .id             = 1,
 361         .resource       = pxa25x_resource_pwm1,
 362         .num_resources  = ARRAY_SIZE(pxa25x_resource_pwm1),
 363 };
 364
 365 static u64 pxa25x_ssp_dma_mask = DMA_BIT_MASK(32);
 366
 367 static struct resource pxa25x_resource_ssp[] = {
 368         [0] = {
 369                 .start  = 0x41000000,
 370                 .end    = 0x4100001f,
 371                 .flags  = IORESOURCE_MEM,
 372         },
 373         [1] = {
 374                 .start  = IRQ_SSP,
 375                 .end    = IRQ_SSP,
 376                 .flags  = IORESOURCE_IRQ,
 377         },
 378         [2] = {
 379                 /* DRCMR for RX */
 380                 .start  = 13,
 381                 .end    = 13,
 382                 .flags  = IORESOURCE_DMA,
 383         },
 384         [3] = {
 385                 /* DRCMR for TX */
 386                 .start  = 14,
 387                 .end    = 14,
 388                 .flags  = IORESOURCE_DMA,
 389         },
 390 };
 391
 392 struct platform_device pxa25x_device_ssp = {
 393         .name           = "pxa25x-ssp",
 394         .id             = 0,
 395         .dev            = {
 396                 .dma_mask = &pxa25x_ssp_dma_mask,
 397                 .coherent_dma_mask = DMA_BIT_MASK(32),
 398         },
 399         .resource       = pxa25x_resource_ssp,
 400         .num_resources  = ARRAY_SIZE(pxa25x_resource_ssp),
 401 };
 402
 403 static u64 pxa25x_nssp_dma_mask = DMA_BIT_MASK(32);
 404
 405 static struct resource pxa25x_resource_nssp[] = {
 406         [0] = {
 407                 .start  = 0x41400000,
 408                 .end    = 0x4140002f,
 409                 .flags  = IORESOURCE_MEM,
 410         },
 411         [1] = {
 412                 .start  = IRQ_NSSP,
 413                 .end    = IRQ_NSSP,
 414                 .flags  = IORESOURCE_IRQ,
 415         },
 416         [2] = {
 417                 /* DRCMR for RX */
 418                 .start  = 15,
 419                 .end    = 15,
 420                 .flags  = IORESOURCE_DMA,
 421         },
 422         [3] = {
 423                 /* DRCMR for TX */
 424                 .start  = 16,
 425                 .end    = 16,
 426                 .flags  = IORESOURCE_DMA,
 427         },
 428 };
 429
 430 struct platform_device pxa25x_device_nssp = {
 431         .name           = "pxa25x-nssp",
 432         .id             = 1,
 433         .dev            = {
 434                 .dma_mask = &pxa25x_nssp_dma_mask,
 435                 .coherent_dma_mask = DMA_BIT_MASK(32),
 436         },
 437         .resource       = pxa25x_resource_nssp,
 438         .num_resources  = ARRAY_SIZE(pxa25x_resource_nssp),
 439 };
 440
 441 static u64 pxa25x_assp_dma_mask = DMA_BIT_MASK(32);
 442
 443 static struct resource pxa25x_resource_assp[] = {
 444         [0] = {
 445                 .start  = 0x41500000,
 446                 .end    = 0x4150002f,
 447                 .flags  = IORESOURCE_MEM,
 448         },
 449         [1] = {
 450                 .start  = IRQ_ASSP,
 451                 .end    = IRQ_ASSP,
 452                 .flags  = IORESOURCE_IRQ,
 453         },
 454         [2] = {
 455                 /* DRCMR for RX */
 456                 .start  = 23,
 457                 .end    = 23,
 458                 .flags  = IORESOURCE_DMA,
 459         },
 460         [3] = {
 461                 /* DRCMR for TX */
 462                 .start  = 24,
 463                 .end    = 24,
 464                 .flags  = IORESOURCE_DMA,
 465         },
 466 };
 467
 468 struct platform_device pxa25x_device_assp = {
 469         /* ASSP is basically equivalent to NSSP */
 470         .name           = "pxa25x-nssp",
 471         .id             = 2,
 472         .dev            = {
 473                 .dma_mask = &pxa25x_assp_dma_mask,
 474                 .coherent_dma_mask = DMA_BIT_MASK(32),
 475         },
 476         .resource       = pxa25x_resource_assp,
 477         .num_resources  = ARRAY_SIZE(pxa25x_resource_assp),
 478 };
 479 #endif /* CONFIG_PXA25x */
 480
 481 #if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
 482
 483 static struct resource pxa27x_resource_keypad[] = {
 484         [0] = {
 485                 .start  = 0x41500000,
 486                 .end    = 0x4150004c,
 487                 .flags  = IORESOURCE_MEM,
 488         },
 489         [1] = {
 490                 .start  = IRQ_KEYPAD,
 491                 .end    = IRQ_KEYPAD,
 492                 .flags  = IORESOURCE_IRQ,
 493         },
 494 };
 495
 496 struct platform_device pxa27x_device_keypad = {
 497         .name           = "pxa27x-keypad",
 498         .id             = -1,
 499         .resource       = pxa27x_resource_keypad,
 500         .num_resources  = ARRAY_SIZE(pxa27x_resource_keypad),
 501 };
 502
 503 void __init pxa_set_keypad_info(struct pxa27x_keypad_platform_data *info)
 504 {
 505         pxa_register_device(&pxa27x_device_keypad, info);
 506 }
 507
 508 static u64 pxa27x_ohci_dma_mask = DMA_BIT_MASK(32);
 509
 510 static struct resource pxa27x_resource_ohci[] = {
 511         [0] = {
 512                 .start  = 0x4C000000,
 513                 .end    = 0x4C00ff6f,
 514                 .flags  = IORESOURCE_MEM,
 515         },
 516         [1] = {
 517                 .start  = IRQ_USBH1,
 518                 .end    = IRQ_USBH1,
 519                 .flags  = IORESOURCE_IRQ,
 520         },
 521 };
 522
 523 struct platform_device pxa27x_device_ohci = {
 524         .name           = "pxa27x-ohci",
 525         .id             = -1,
 526         .dev            = {
 527                 .dma_mask = &pxa27x_ohci_dma_mask,
 528                 .coherent_dma_mask = DMA_BIT_MASK(32),
 529         },
 530         .num_resources  = ARRAY_SIZE(pxa27x_resource_ohci),
 531         .resource       = pxa27x_resource_ohci,
 532 };
 533
 534 void __init pxa_set_ohci_info(struct pxaohci_platform_data *info)
 535 {
 536         pxa_register_device(&pxa27x_device_ohci, info);
 537 }
 538
 539 static u64 pxa27x_ssp1_dma_mask = DMA_BIT_MASK(32);
 540
 541 static struct resource pxa27x_resource_ssp1[] = {
 542         [0] = {
 543                 .start  = 0x41000000,
 544                 .end    = 0x4100003f,
 545                 .flags  = IORESOURCE_MEM,
 546         },
 547         [1] = {
 548                 .start  = IRQ_SSP,
 549                 .end    = IRQ_SSP,
 550                 .flags  = IORESOURCE_IRQ,
 551         },
 552         [2] = {
 553                 /* DRCMR for RX */
 554                 .start  = 13,
 555                 .end    = 13,
 556                 .flags  = IORESOURCE_DMA,
 557         },
 558         [3] = {
 559                 /* DRCMR for TX */
 560                 .start  = 14,
 561                 .end    = 14,
 562                 .flags  = IORESOURCE_DMA,
 563         },
 564 };
 565
 566 struct platform_device pxa27x_device_ssp1 = {
 567         .name           = "pxa27x-ssp",
 568         .id             = 0,
 569         .dev            = {
 570                 .dma_mask = &pxa27x_ssp1_dma_mask,
 571                 .coherent_dma_mask = DMA_BIT_MASK(32),
 572         },
 573         .resource       = pxa27x_resource_ssp1,
 574         .num_resources  = ARRAY_SIZE(pxa27x_resource_ssp1),
 575 };
 576
 577 static u64 pxa27x_ssp2_dma_mask = DMA_BIT_MASK(32);
 578
 579 static struct resource pxa27x_resource_ssp2[] = {
 580         [0] = {
 581                 .start  = 0x41700000,
 582                 .end    = 0x4170003f,
 583                 .flags  = IORESOURCE_MEM,
 584         },
 585         [1] = {
 586                 .start  = IRQ_SSP2,
 587                 .end    = IRQ_SSP2,
 588                 .flags  = IORESOURCE_IRQ,
 589         },
 590         [2] = {
 591                 /* DRCMR for RX */
 592                 .start  = 15,
 593                 .end    = 15,
 594                 .flags  = IORESOURCE_DMA,
 595         },
 596         [3] = {
 597                 /* DRCMR for TX */
 598                 .start  = 16,
 599                 .end    = 16,
 600                 .flags  = IORESOURCE_DMA,
 601         },
 602 };
 603
 604 struct platform_device pxa27x_device_ssp2 = {
 605         .name           = "pxa27x-ssp",
 606         .id             = 1,
 607         .dev            = {
 608                 .dma_mask = &pxa27x_ssp2_dma_mask,
 609                 .coherent_dma_mask = DMA_BIT_MASK(32),
 610         },
 611         .resource       = pxa27x_resource_ssp2,
 612         .num_resources  = ARRAY_SIZE(pxa27x_resource_ssp2),
 613 };
 614
 615 static u64 pxa27x_ssp3_dma_mask = DMA_BIT_MASK(32);
 616
 617 static struct resource pxa27x_resource_ssp3[] = {
 618         [0] = {
 619                 .start  = 0x41900000,
 620                 .end    = 0x4190003f,
 621                 .flags  = IORESOURCE_MEM,
 622         },
 623         [1] = {
 624                 .start  = IRQ_SSP3,
 625                 .end    = IRQ_SSP3,
 626                 .flags  = IORESOURCE_IRQ,
 627         },
 628         [2] = {
 629                 /* DRCMR for RX */
 630                 .start  = 66,
 631                 .end    = 66,
 632                 .flags  = IORESOURCE_DMA,
 633         },
 634         [3] = {
 635                 /* DRCMR for TX */
 636                 .start  = 67,
 637                 .end    = 67,
 638                 .flags  = IORESOURCE_DMA,
 639         },
 640 };
 641
 642 struct platform_device pxa27x_device_ssp3 = {
 643         .name           = "pxa27x-ssp",
 644         .id             = 2,
 645         .dev            = {
 646                 .dma_mask = &pxa27x_ssp3_dma_mask,
 647                 .coherent_dma_mask = DMA_BIT_MASK(32),
 648         },
 649         .resource       = pxa27x_resource_ssp3,
 650         .num_resources  = ARRAY_SIZE(pxa27x_resource_ssp3),
 651 };
 652
 653 static struct resource pxa27x_resource_pwm0[] = {
 654         [0] = {
 655                 .start  = 0x40b00000,
 656                 .end    = 0x40b0001f,
 657                 .flags  = IORESOURCE_MEM,
 658         },
 659 };
 660
 661 struct platform_device pxa27x_device_pwm0 = {
 662         .name           = "pxa27x-pwm",
 663         .id             = 0,
 664         .resource       = pxa27x_resource_pwm0,
 665         .num_resources  = ARRAY_SIZE(pxa27x_resource_pwm0),
 666 };
 667
 668 static struct resource pxa27x_resource_pwm1[] = {
 669         [0] = {
 670                 .start  = 0x40c00000,
 671                 .end    = 0x40c0001f,
 672                 .flags  = IORESOURCE_MEM,
 673         },
 674 };
 675
 676 struct platform_device pxa27x_device_pwm1 = {
 677         .name           = "pxa27x-pwm",
 678         .id             = 1,
 679         .resource       = pxa27x_resource_pwm1,
 680         .num_resources  = ARRAY_SIZE(pxa27x_resource_pwm1),
 681 };
 682
 683 static struct resource pxa27x_resource_camera[] = {
 684         [0] = {
 685                 .start  = 0x50000000,
 686                 .end    = 0x50000fff,
 687                 .flags  = IORESOURCE_MEM,
 688         },
 689         [1] = {
 690                 .start  = IRQ_CAMERA,
 691                 .end    = IRQ_CAMERA,
 692                 .flags  = IORESOURCE_IRQ,
 693         },
 694 };
 695
 696 static u64 pxa27x_dma_mask_camera = DMA_BIT_MASK(32);
 697
 698 static struct platform_device pxa27x_device_camera = {
 699         .name           = "pxa27x-camera",
 700         .id             = 0, /* This is used to put cameras on this interface */
 701         .dev            = {
 702                 .dma_mask               = &pxa27x_dma_mask_camera,
 703                 .coherent_dma_mask      = 0xffffffff,
 704         },
 705         .num_resources  = ARRAY_SIZE(pxa27x_resource_camera),
 706         .resource       = pxa27x_resource_camera,
 707 };
 708
 709 void __init pxa_set_camera_info(struct pxacamera_platform_data *info)
 710 {
 711         pxa_register_device(&pxa27x_device_camera, info);
 712 }
 713 #endif /* CONFIG_PXA27x || CONFIG_PXA3xx */
 714
 715 #ifdef CONFIG_PXA3xx
 716 static u64 pxa3xx_ssp4_dma_mask = DMA_BIT_MASK(32);
 717
 718 static struct resource pxa3xx_resource_ssp4[] = {
 719         [0] = {
 720                 .start  = 0x41a00000,
 721                 .end    = 0x41a0003f,
 722                 .flags  = IORESOURCE_MEM,
 723         },
 724         [1] = {
 725                 .start  = IRQ_SSP4,
 726                 .end    = IRQ_SSP4,
 727                 .flags  = IORESOURCE_IRQ,
 728         },
 729         [2] = {
 730                 /* DRCMR for RX */
 731                 .start  = 2,
 732                 .end    = 2,
 733                 .flags  = IORESOURCE_DMA,
 734         },
 735         [3] = {
 736                 /* DRCMR for TX */
 737                 .start  = 3,
 738                 .end    = 3,
 739                 .flags  = IORESOURCE_DMA,
 740         },
 741 };
 742
 743 struct platform_device pxa3xx_device_ssp4 = {
 744         /* PXA3xx SSP is basically equivalent to PXA27x */
 745         .name           = "pxa27x-ssp",
 746         .id             = 3,
 747         .dev            = {
 748                 .dma_mask = &pxa3xx_ssp4_dma_mask,
 749                 .coherent_dma_mask = DMA_BIT_MASK(32),
 750         },
 751         .resource       = pxa3xx_resource_ssp4,
 752         .num_resources  = ARRAY_SIZE(pxa3xx_resource_ssp4),
 753 };
 754
 755 static struct resource pxa3xx_resources_mci2[] = {
 756         [0] = {
 757                 .start  = 0x42000000,
 758                 .end    = 0x42000fff,
 759                 .flags  = IORESOURCE_MEM,
 760         },
 761         [1] = {
 762                 .start  = IRQ_MMC2,
 763                 .end    = IRQ_MMC2,
 764                 .flags  = IORESOURCE_IRQ,
 765         },
 766         [2] = {
 767                 .start  = 93,
 768                 .end    = 93,
 769                 .flags  = IORESOURCE_DMA,
 770         },
 771         [3] = {
 772                 .start  = 94,
 773                 .end    = 94,
 774                 .flags  = IORESOURCE_DMA,
 775         },
 776 };
 777
 778 struct platform_device pxa3xx_device_mci2 = {
 779         .name           = "pxa2xx-mci",
 780         .id             = 1,
 781         .dev            = {
 782                 .dma_mask = &pxamci_dmamask,
 783                 .coherent_dma_mask =    0xffffffff,
 784         },
 785         .num_resources  = ARRAY_SIZE(pxa3xx_resources_mci2),
 786         .resource       = pxa3xx_resources_mci2,
 787 };
 788
 789 void __init pxa3xx_set_mci2_info(struct pxamci_platform_data *info)
 790 {
 791         pxa_register_device(&pxa3xx_device_mci2, info);
 792 }
 793
 794 static struct resource pxa3xx_resources_mci3[] = {
 795         [0] = {
 796                 .start  = 0x42500000,
 797                 .end    = 0x42500fff,
 798                 .flags  = IORESOURCE_MEM,
 799         },
 800         [1] = {
 801                 .start  = IRQ_MMC3,
 802                 .end    = IRQ_MMC3,
 803                 .flags  = IORESOURCE_IRQ,
 804         },
 805         [2] = {
 806                 .start  = 100,
 807                 .end    = 100,
 808                 .flags  = IORESOURCE_DMA,
 809         },
 810         [3] = {
 811                 .start  = 101,
 812                 .end    = 101,
 813                 .flags  = IORESOURCE_DMA,
 814         },
 815 };
 816
 817 struct platform_device pxa3xx_device_mci3 = {
 818         .name           = "pxa2xx-mci",
 819         .id             = 2,
 820         .dev            = {
 821                 .dma_mask = &pxamci_dmamask,
 822                 .coherent_dma_mask = 0xffffffff,
 823         },
 824         .num_resources  = ARRAY_SIZE(pxa3xx_resources_mci3),
 825         .resource       = pxa3xx_resources_mci3,
 826 };
 827
 828 void __init pxa3xx_set_mci3_info(struct pxamci_platform_data *info)
 829 {
 830         pxa_register_device(&pxa3xx_device_mci3, info);
 831 }
 832
 833 #endif /* CONFIG_PXA3xx */