arm/tegra: Prep boards for gpio/pinmux conversion to pdevs
[linux-2.6.git] / 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 };