arch/arm/mach-tegra/devices.c

   1 /*
   2  * Copyright (C) 2010,2011 Google, Inc.
   3  *
   4  * Author:
   5  *      Colin Cross <ccross@android.com>
   6  *      Erik Gilling <ccross@android.com>
   7  *
   8  * This software is licensed under the terms of the GNU General Public
   9  * License version 2, as published by the Free Software Foundation, and
  10  * may be copied, distributed, and modified under those terms.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  */
  18
  19
  20 #include <linux/resource.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/dma-mapping.h>
  23 #include <linux/fsl_devices.h>
  24 #include <linux/serial_8250.h>
  25 #include <linux/i2c-tegra.h>
  26 #include <linux/platform_data/tegra_usb.h>
  27 #include <asm/pmu.h>
  28 #include <mach/irqs.h>
  29 #include <mach/iomap.h>
  30 #include <mach/dma.h>
  31 #include <mach/usb_phy.h>
  32 #include "gpio-names.h"
  33
  34 static struct resource gpio_resource[] = {
  35         [0] = {
  36                 .start  = TEGRA_GPIO_BASE,
  37                 .end    = TEGRA_GPIO_BASE + TEGRA_GPIO_SIZE-1,
  38                 .flags  = IORESOURCE_MEM,
  39         },
  40         [1] = {
  41                 .start  = INT_GPIO1,
  42                 .end    = INT_GPIO1,
  43                 .flags  = IORESOURCE_IRQ,
  44         },
  45         [2] = {
  46                 .start  = INT_GPIO2,
  47                 .end    = INT_GPIO2,
  48                 .flags  = IORESOURCE_IRQ,
  49         },
  50         [3] = {
  51                 .start  = INT_GPIO3,
  52                 .end    = INT_GPIO3,
  53                 .flags  = IORESOURCE_IRQ,
  54         },
  55         [4] = {
  56                 .start  = INT_GPIO4,
  57                 .end    = INT_GPIO4,
  58                 .flags  = IORESOURCE_IRQ,
  59         },
  60         [5] = {
  61                 .start  = INT_GPIO5,
  62                 .end    = INT_GPIO5,
  63                 .flags  = IORESOURCE_IRQ,
  64         },
  65         [6] = {
  66                 .start  = INT_GPIO6,
  67                 .end    = INT_GPIO6,
  68                 .flags  = IORESOURCE_IRQ,
  69         },
  70         [7] = {
  71                 .start  = INT_GPIO7,
  72                 .end    = INT_GPIO7,
  73                 .flags  = IORESOURCE_IRQ,
  74         },
  75 };
  76
  77 struct platform_device tegra_gpio_device = {
  78         .name           = "tegra-gpio",
  79         .id             = -1,
  80         .resource       = gpio_resource,
  81         .num_resources  = ARRAY_SIZE(gpio_resource),
  82 };
  83
  84 static struct resource pinmux_resource[] = {
  85         [0] = {
  86                 /* Tri-state registers */
  87                 .start  = TEGRA_APB_MISC_BASE + 0x14,
  88                 .end    = TEGRA_APB_MISC_BASE + 0x20 + 3,
  89                 .flags  = IORESOURCE_MEM,
  90         },
  91         [1] = {
  92                 /* Mux registers */
  93                 .start  = TEGRA_APB_MISC_BASE + 0x80,
  94                 .end    = TEGRA_APB_MISC_BASE + 0x9c + 3,
  95                 .flags  = IORESOURCE_MEM,
  96         },
  97         [2] = {
  98                 /* Pull-up/down registers */
  99                 .start  = TEGRA_APB_MISC_BASE + 0xa0,
 100                 .end    = TEGRA_APB_MISC_BASE + 0xb0 + 3,
 101                 .flags  = IORESOURCE_MEM,
 102         },
 103         [3] = {
 104                 /* Pad control registers */
 105                 .start  = TEGRA_APB_MISC_BASE + 0x868,
 106                 .end    = TEGRA_APB_MISC_BASE + 0x90c + 3,
 107                 .flags  = IORESOURCE_MEM,
 108         },
 109 };
 110
 111 struct platform_device tegra_pinmux_device = {
 112         .name           = "tegra-pinmux",
 113         .id             = -1,
 114         .resource       = pinmux_resource,
 115         .num_resources  = ARRAY_SIZE(pinmux_resource),
 116 };
 117
 118 static struct resource i2c_resource1[] = {
 119         [0] = {
 120                 .start  = INT_I2C,
 121                 .end    = INT_I2C,
 122                 .flags  = IORESOURCE_IRQ,
 123         },
 124         [1] = {
 125                 .start  = TEGRA_I2C_BASE,
 126                 .end    = TEGRA_I2C_BASE + TEGRA_I2C_SIZE-1,
 127                 .flags  = IORESOURCE_MEM,
 128         },
 129 };
 130
 131 static struct resource i2c_resource2[] = {
 132         [0] = {
 133                 .start  = INT_I2C2,
 134                 .end    = INT_I2C2,
 135                 .flags  = IORESOURCE_IRQ,
 136         },
 137         [1] = {
 138                 .start  = TEGRA_I2C2_BASE,
 139                 .end    = TEGRA_I2C2_BASE + TEGRA_I2C2_SIZE-1,
 140                 .flags  = IORESOURCE_MEM,
 141         },
 142 };
 143
 144 static struct resource i2c_resource3[] = {
 145         [0] = {
 146                 .start  = INT_I2C3,
 147                 .end    = INT_I2C3,
 148                 .flags  = IORESOURCE_IRQ,
 149         },
 150         [1] = {
 151                 .start  = TEGRA_I2C3_BASE,
 152                 .end    = TEGRA_I2C3_BASE + TEGRA_I2C3_SIZE-1,
 153                 .flags  = IORESOURCE_MEM,
 154         },
 155 };
 156
 157 static struct resource i2c_resource4[] = {
 158         [0] = {
 159                 .start  = INT_DVC,
 160                 .end    = INT_DVC,
 161                 .flags  = IORESOURCE_IRQ,
 162         },
 163         [1] = {
 164                 .start  = TEGRA_DVC_BASE,
 165                 .end    = TEGRA_DVC_BASE + TEGRA_DVC_SIZE-1,
 166                 .flags  = IORESOURCE_MEM,
 167         },
 168 };
 169
 170 static struct tegra_i2c_platform_data tegra_i2c1_platform_data = {
 171         .bus_clk_rate   = 400000,
 172 };
 173
 174 static struct tegra_i2c_platform_data tegra_i2c2_platform_data = {
 175         .bus_clk_rate   = 400000,
 176 };
 177
 178 static struct tegra_i2c_platform_data tegra_i2c3_platform_data = {
 179         .bus_clk_rate   = 400000,
 180 };
 181
 182 static struct tegra_i2c_platform_data tegra_dvc_platform_data = {
 183         .bus_clk_rate   = 400000,
 184 };
 185
 186 struct platform_device tegra_i2c_device1 = {
 187         .name           = "tegra-i2c",
 188         .id             = 0,
 189         .resource       = i2c_resource1,
 190         .num_resources  = ARRAY_SIZE(i2c_resource1),
 191         .dev = {
 192                 .platform_data = &tegra_i2c1_platform_data,
 193         },
 194 };
 195
 196 struct platform_device tegra_i2c_device2 = {
 197         .name           = "tegra-i2c",
 198         .id             = 1,
 199         .resource       = i2c_resource2,
 200         .num_resources  = ARRAY_SIZE(i2c_resource2),
 201         .dev = {
 202                 .platform_data = &tegra_i2c2_platform_data,
 203         },
 204 };
 205
 206 struct platform_device tegra_i2c_device3 = {
 207         .name           = "tegra-i2c",
 208         .id             = 2,
 209         .resource       = i2c_resource3,
 210         .num_resources  = ARRAY_SIZE(i2c_resource3),
 211         .dev = {
 212                 .platform_data = &tegra_i2c3_platform_data,
 213         },
 214 };
 215
 216 struct platform_device tegra_i2c_device4 = {
 217         .name           = "tegra-i2c",
 218         .id             = 3,
 219         .resource       = i2c_resource4,
 220         .num_resources  = ARRAY_SIZE(i2c_resource4),
 221         .dev = {
 222                 .platform_data = &tegra_dvc_platform_data,
 223         },
 224 };
 225
 226 static struct resource spi_resource1[] = {
 227         [0] = {
 228                 .start  = INT_S_LINK1,
 229                 .end    = INT_S_LINK1,
 230                 .flags  = IORESOURCE_IRQ,
 231         },
 232         [1] = {
 233                 .start  = TEGRA_SPI1_BASE,
 234                 .end    = TEGRA_SPI1_BASE + TEGRA_SPI1_SIZE-1,
 235                 .flags  = IORESOURCE_MEM,
 236         },
 237 };
 238
 239 static struct resource spi_resource2[] = {
 240         [0] = {
 241                 .start  = INT_SPI_2,
 242                 .end    = INT_SPI_2,
 243                 .flags  = IORESOURCE_IRQ,
 244         },
 245         [1] = {
 246                 .start  = TEGRA_SPI2_BASE,
 247                 .end    = TEGRA_SPI2_BASE + TEGRA_SPI2_SIZE-1,
 248                 .flags  = IORESOURCE_MEM,
 249         },
 250 };
 251
 252 static struct resource spi_resource3[] = {
 253         [0] = {
 254                 .start  = INT_SPI_3,
 255                 .end    = INT_SPI_3,
 256                 .flags  = IORESOURCE_IRQ,
 257         },
 258         [1] = {
 259                 .start  = TEGRA_SPI3_BASE,
 260                 .end    = TEGRA_SPI3_BASE + TEGRA_SPI3_SIZE-1,
 261                 .flags  = IORESOURCE_MEM,
 262         },
 263 };
 264
 265 static struct resource spi_resource4[] = {
 266         [0] = {
 267                 .start  = INT_SPI_4,
 268                 .end    = INT_SPI_4,
 269                 .flags  = IORESOURCE_IRQ,
 270         },
 271         [1] = {
 272                 .start  = TEGRA_SPI4_BASE,
 273                 .end    = TEGRA_SPI4_BASE + TEGRA_SPI4_SIZE-1,
 274                 .flags  = IORESOURCE_MEM,
 275         },
 276 };
 277
 278 struct platform_device tegra_spi_device1 = {
 279         .name           = "spi_tegra",
 280         .id             = 0,
 281         .resource       = spi_resource1,
 282         .num_resources  = ARRAY_SIZE(spi_resource1),
 283         .dev            = {
 284                 .coherent_dma_mask      = 0xffffffff,
 285         },
 286 };
 287
 288 struct platform_device tegra_spi_device2 = {
 289         .name           = "spi_tegra",
 290         .id             = 1,
 291         .resource       = spi_resource2,
 292         .num_resources  = ARRAY_SIZE(spi_resource2),
 293         .dev            = {
 294                 .coherent_dma_mask      = 0xffffffff,
 295         },
 296 };
 297
 298 struct platform_device tegra_spi_device3 = {
 299         .name           = "spi_tegra",
 300         .id             = 2,
 301         .resource       = spi_resource3,
 302         .num_resources  = ARRAY_SIZE(spi_resource3),
 303         .dev            = {
 304                 .coherent_dma_mask      = 0xffffffff,
 305         },
 306 };
 307
 308 struct platform_device tegra_spi_device4 = {
 309         .name           = "spi_tegra",
 310         .id             = 3,
 311         .resource       = spi_resource4,
 312         .num_resources  = ARRAY_SIZE(spi_resource4),
 313         .dev            = {
 314                 .coherent_dma_mask      = 0xffffffff,
 315         },
 316 };
 317
 318
 319 static struct resource sdhci_resource1[] = {
 320         [0] = {
 321                 .start  = INT_SDMMC1,
 322                 .end    = INT_SDMMC1,
 323                 .flags  = IORESOURCE_IRQ,
 324         },
 325         [1] = {
 326                 .start  = TEGRA_SDMMC1_BASE,
 327                 .end    = TEGRA_SDMMC1_BASE + TEGRA_SDMMC1_SIZE-1,
 328                 .flags  = IORESOURCE_MEM,
 329         },
 330 };
 331
 332 static struct resource sdhci_resource2[] = {
 333         [0] = {
 334                 .start  = INT_SDMMC2,
 335                 .end    = INT_SDMMC2,
 336                 .flags  = IORESOURCE_IRQ,
 337         },
 338         [1] = {
 339                 .start  = TEGRA_SDMMC2_BASE,
 340                 .end    = TEGRA_SDMMC2_BASE + TEGRA_SDMMC2_SIZE-1,
 341                 .flags  = IORESOURCE_MEM,
 342         },
 343 };
 344
 345 static struct resource sdhci_resource3[] = {
 346         [0] = {
 347                 .start  = INT_SDMMC3,
 348                 .end    = INT_SDMMC3,
 349                 .flags  = IORESOURCE_IRQ,
 350         },
 351         [1] = {
 352                 .start  = TEGRA_SDMMC3_BASE,
 353                 .end    = TEGRA_SDMMC3_BASE + TEGRA_SDMMC3_SIZE-1,
 354                 .flags  = IORESOURCE_MEM,
 355         },
 356 };
 357
 358 static struct resource sdhci_resource4[] = {
 359         [0] = {
 360                 .start  = INT_SDMMC4,
 361                 .end    = INT_SDMMC4,
 362                 .flags  = IORESOURCE_IRQ,
 363         },
 364         [1] = {
 365                 .start  = TEGRA_SDMMC4_BASE,
 366                 .end    = TEGRA_SDMMC4_BASE + TEGRA_SDMMC4_SIZE-1,
 367                 .flags  = IORESOURCE_MEM,
 368         },
 369 };
 370
 371 /* board files should fill in platform_data register the devices themselvs.
 372  * See board-harmony.c for an example
 373  */
 374 struct platform_device tegra_sdhci_device1 = {
 375         .name           = "sdhci-tegra",
 376         .id             = 0,
 377         .resource       = sdhci_resource1,
 378         .num_resources  = ARRAY_SIZE(sdhci_resource1),
 379 };
 380
 381 struct platform_device tegra_sdhci_device2 = {
 382         .name           = "sdhci-tegra",
 383         .id             = 1,
 384         .resource       = sdhci_resource2,
 385         .num_resources  = ARRAY_SIZE(sdhci_resource2),
 386 };
 387
 388 struct platform_device tegra_sdhci_device3 = {
 389         .name           = "sdhci-tegra",
 390         .id             = 2,
 391         .resource       = sdhci_resource3,
 392         .num_resources  = ARRAY_SIZE(sdhci_resource3),
 393 };
 394
 395 struct platform_device tegra_sdhci_device4 = {
 396         .name           = "sdhci-tegra",
 397         .id             = 3,
 398         .resource       = sdhci_resource4,
 399         .num_resources  = ARRAY_SIZE(sdhci_resource4),
 400 };
 401
 402 static struct resource tegra_usb1_resources[] = {
 403         [0] = {
 404                 .start  = TEGRA_USB_BASE,
 405                 .end    = TEGRA_USB_BASE + TEGRA_USB_SIZE - 1,
 406                 .flags  = IORESOURCE_MEM,
 407         },
 408         [1] = {
 409                 .start  = INT_USB,
 410                 .end    = INT_USB,
 411                 .flags  = IORESOURCE_IRQ,
 412         },
 413 };
 414
 415 static struct resource tegra_usb2_resources[] = {
 416         [0] = {
 417                 .start  = TEGRA_USB2_BASE,
 418                 .end    = TEGRA_USB2_BASE + TEGRA_USB2_SIZE - 1,
 419                 .flags  = IORESOURCE_MEM,
 420         },
 421         [1] = {
 422                 .start  = INT_USB2,
 423                 .end    = INT_USB2,
 424                 .flags  = IORESOURCE_IRQ,
 425         },
 426 };
 427
 428 static struct resource tegra_usb3_resources[] = {
 429         [0] = {
 430                 .start  = TEGRA_USB3_BASE,
 431                 .end    = TEGRA_USB3_BASE + TEGRA_USB3_SIZE - 1,
 432                 .flags  = IORESOURCE_MEM,
 433         },
 434         [1] = {
 435                 .start  = INT_USB3,
 436                 .end    = INT_USB3,
 437                 .flags  = IORESOURCE_IRQ,
 438         },
 439 };
 440
 441 static struct tegra_ulpi_config tegra_ehci2_ulpi_phy_config = {
 442         /* All existing boards use GPIO PV0 for phy reset */
 443         .reset_gpio = TEGRA_GPIO_PV0,
 444         .clk = "cdev2",
 445 };
 446
 447 static struct tegra_ehci_platform_data tegra_ehci1_pdata = {
 448         .operating_mode = TEGRA_USB_OTG,
 449         .power_down_on_bus_suspend = 1,
 450 };
 451
 452 static struct tegra_ehci_platform_data tegra_ehci2_pdata = {
 453         .phy_config = &tegra_ehci2_ulpi_phy_config,
 454         .operating_mode = TEGRA_USB_HOST,
 455         .power_down_on_bus_suspend = 1,
 456 };
 457
 458 static struct tegra_ehci_platform_data tegra_ehci3_pdata = {
 459         .operating_mode = TEGRA_USB_HOST,
 460         .power_down_on_bus_suspend = 1,
 461 };
 462
 463 static u64 tegra_ehci_dmamask = DMA_BIT_MASK(32);
 464
 465 struct platform_device tegra_ehci1_device = {
 466         .name   = "tegra-ehci",
 467         .id     = 0,
 468         .dev    = {
 469                 .dma_mask       = &tegra_ehci_dmamask,
 470                 .coherent_dma_mask = DMA_BIT_MASK(32),
 471                 .platform_data = &tegra_ehci1_pdata,
 472         },
 473         .resource = tegra_usb1_resources,
 474         .num_resources = ARRAY_SIZE(tegra_usb1_resources),
 475 };
 476
 477 struct platform_device tegra_ehci2_device = {
 478         .name   = "tegra-ehci",
 479         .id     = 1,
 480         .dev    = {
 481                 .dma_mask       = &tegra_ehci_dmamask,
 482                 .coherent_dma_mask = DMA_BIT_MASK(32),
 483                 .platform_data = &tegra_ehci2_pdata,
 484         },
 485         .resource = tegra_usb2_resources,
 486         .num_resources = ARRAY_SIZE(tegra_usb2_resources),
 487 };
 488
 489 struct platform_device tegra_ehci3_device = {
 490         .name   = "tegra-ehci",
 491         .id     = 2,
 492         .dev    = {
 493                 .dma_mask       = &tegra_ehci_dmamask,
 494                 .coherent_dma_mask = DMA_BIT_MASK(32),
 495                 .platform_data = &tegra_ehci3_pdata,
 496         },
 497         .resource = tegra_usb3_resources,
 498         .num_resources = ARRAY_SIZE(tegra_usb3_resources),
 499 };
 500
 501 static struct resource tegra_pmu_resources[] = {
 502         [0] = {
 503                 .start  = INT_CPU0_PMU_INTR,
 504                 .end    = INT_CPU0_PMU_INTR,
 505                 .flags  = IORESOURCE_IRQ,
 506         },
 507         [1] = {
 508                 .start  = INT_CPU1_PMU_INTR,
 509                 .end    = INT_CPU1_PMU_INTR,
 510                 .flags  = IORESOURCE_IRQ,
 511         },
 512 };
 513
 514 struct platform_device tegra_pmu_device = {
 515         .name           = "arm-pmu",
 516         .id             = ARM_PMU_DEVICE_CPU,
 517         .num_resources  = ARRAY_SIZE(tegra_pmu_resources),
 518         .resource       = tegra_pmu_resources,
 519 };
 520
 521 static struct resource tegra_uarta_resources[] = {
 522         [0] = {
 523                 .start  = TEGRA_UARTA_BASE,
 524                 .end    = TEGRA_UARTA_BASE + TEGRA_UARTA_SIZE - 1,
 525                 .flags  = IORESOURCE_MEM,
 526         },
 527         [1] = {
 528                 .start  = INT_UARTA,
 529                 .end    = INT_UARTA,
 530                 .flags  = IORESOURCE_IRQ,
 531         },
 532 };
 533
 534 static struct resource tegra_uartb_resources[] = {
 535         [0] = {
 536                 .start  = TEGRA_UARTB_BASE,
 537                 .end    = TEGRA_UARTB_BASE + TEGRA_UARTB_SIZE - 1,
 538                 .flags  = IORESOURCE_MEM,
 539         },
 540         [1] = {
 541                 .start  = INT_UARTB,
 542                 .end    = INT_UARTB,
 543                 .flags  = IORESOURCE_IRQ,
 544         },
 545 };
 546
 547 static struct resource tegra_uartc_resources[] = {
 548         [0] = {
 549                 .start  = TEGRA_UARTC_BASE,
 550                 .end    = TEGRA_UARTC_BASE + TEGRA_UARTC_SIZE - 1,
 551                 .flags  = IORESOURCE_MEM,
 552         },
 553         [1] = {
 554                 .start  = INT_UARTC,
 555                 .end    = INT_UARTC,
 556                 .flags  = IORESOURCE_IRQ,
 557         },
 558 };
 559
 560 static struct resource tegra_uartd_resources[] = {
 561         [0] = {
 562                 .start  = TEGRA_UARTD_BASE,
 563                 .end    = TEGRA_UARTD_BASE + TEGRA_UARTD_SIZE - 1,
 564                 .flags  = IORESOURCE_MEM,
 565         },
 566         [1] = {
 567                 .start  = INT_UARTD,
 568                 .end    = INT_UARTD,
 569                 .flags  = IORESOURCE_IRQ,
 570         },
 571 };
 572
 573 static struct resource tegra_uarte_resources[] = {
 574         [0] = {
 575                 .start  = TEGRA_UARTE_BASE,
 576                 .end    = TEGRA_UARTE_BASE + TEGRA_UARTE_SIZE - 1,
 577                 .flags  = IORESOURCE_MEM,
 578         },
 579         [1] = {
 580                 .start  = INT_UARTE,
 581                 .end    = INT_UARTE,
 582                 .flags  = IORESOURCE_IRQ,
 583         },
 584 };
 585
 586 struct platform_device tegra_uarta_device = {
 587         .name   = "tegra_uart",
 588         .id     = 0,
 589         .num_resources  = ARRAY_SIZE(tegra_uarta_resources),
 590         .resource       = tegra_uarta_resources,
 591         .dev    = {
 592                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 593         },
 594 };
 595
 596 struct platform_device tegra_uartb_device = {
 597         .name   = "tegra_uart",
 598         .id     = 1,
 599         .num_resources  = ARRAY_SIZE(tegra_uartb_resources),
 600         .resource       = tegra_uartb_resources,
 601         .dev    = {
 602                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 603         },
 604 };
 605
 606 struct platform_device tegra_uartc_device = {
 607         .name   = "tegra_uart",
 608         .id     = 2,
 609         .num_resources  = ARRAY_SIZE(tegra_uartc_resources),
 610         .resource       = tegra_uartc_resources,
 611         .dev    = {
 612                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 613         },
 614 };
 615
 616 struct platform_device tegra_uartd_device = {
 617         .name   = "tegra_uart",
 618         .id     = 3,
 619         .num_resources  = ARRAY_SIZE(tegra_uartd_resources),
 620         .resource       = tegra_uartd_resources,
 621         .dev    = {
 622                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 623         },
 624 };
 625
 626 struct platform_device tegra_uarte_device = {
 627         .name   = "tegra_uart",
 628         .id     = 4,
 629         .num_resources  = ARRAY_SIZE(tegra_uarte_resources),
 630         .resource       = tegra_uarte_resources,
 631         .dev    = {
 632                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 633         },
 634 };
 635
 636 static struct resource i2s_resource1[] = {
 637         [0] = {
 638                 .start  = INT_I2S1,
 639                 .end    = INT_I2S1,
 640                 .flags  = IORESOURCE_IRQ
 641         },
 642         [1] = {
 643                 .start  = TEGRA_DMA_REQ_SEL_I2S_1,
 644                 .end    = TEGRA_DMA_REQ_SEL_I2S_1,
 645                 .flags  = IORESOURCE_DMA
 646         },
 647         [2] = {
 648                 .start  = TEGRA_I2S1_BASE,
 649                 .end    = TEGRA_I2S1_BASE + TEGRA_I2S1_SIZE - 1,
 650                 .flags  = IORESOURCE_MEM
 651         }
 652 };
 653
 654 static struct resource i2s_resource2[] = {
 655         [0] = {
 656                 .start  = INT_I2S2,
 657                 .end    = INT_I2S2,
 658                 .flags  = IORESOURCE_IRQ
 659         },
 660         [1] = {
 661                 .start  = TEGRA_DMA_REQ_SEL_I2S2_1,
 662                 .end    = TEGRA_DMA_REQ_SEL_I2S2_1,
 663                 .flags  = IORESOURCE_DMA
 664         },
 665         [2] = {
 666                 .start  = TEGRA_I2S2_BASE,
 667                 .end    = TEGRA_I2S2_BASE + TEGRA_I2S2_SIZE - 1,
 668                 .flags  = IORESOURCE_MEM
 669         }
 670 };
 671
 672 struct platform_device tegra_i2s_device1 = {
 673         .name           = "tegra-i2s",
 674         .id             = 0,
 675         .resource       = i2s_resource1,
 676         .num_resources  = ARRAY_SIZE(i2s_resource1),
 677 };
 678
 679 struct platform_device tegra_i2s_device2 = {
 680         .name           = "tegra-i2s",
 681         .id             = 1,
 682         .resource       = i2s_resource2,
 683         .num_resources  = ARRAY_SIZE(i2s_resource2),
 684 };
 685
 686 static struct resource tegra_das_resources[] = {
 687         [0] = {
 688                 .start = TEGRA_APB_MISC_DAS_BASE,
 689                 .end = TEGRA_APB_MISC_DAS_BASE + TEGRA_APB_MISC_DAS_SIZE - 1,
 690                 .flags = IORESOURCE_MEM,
 691         },
 692 };
 693
 694 struct platform_device tegra_das_device = {
 695         .name           = "tegra-das",
 696         .id             = -1,
 697         .num_resources  = ARRAY_SIZE(tegra_das_resources),
 698         .resource       = tegra_das_resources,
 699 };
 700
 701 struct platform_device tegra_pcm_device = {
 702         .name = "tegra-pcm-audio",
 703         .id = -1,
 704 };