arch/arm/mach-davinci/devices-da8xx.c

   1 /*
   2  * DA8XX/OMAP L1XX platform device data
   3  *
   4  * Copyright (c) 2007-2009, MontaVista Software, Inc. <source@mvista.com>
   5  * Derived from code that was:
   6  *      Copyright (C) 2006 Komal Shah <komal_shah802003@yahoo.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  */
  13 #include <linux/init.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/dma-contiguous.h>
  16 #include <linux/serial_8250.h>
  17 #include <linux/ahci_platform.h>
  18 #include <linux/clk.h>
  19 #include <linux/reboot.h>
  20
  21 #include <mach/cputype.h>
  22 #include <mach/common.h>
  23 #include <mach/time.h>
  24 #include <mach/da8xx.h>
  25 #include <mach/cpuidle.h>
  26 #include <mach/sram.h>
  27
  28 #include "clock.h"
  29 #include "asp.h"
  30
  31 #define DA8XX_TPCC_BASE                 0x01c00000
  32 #define DA8XX_TPTC0_BASE                0x01c08000
  33 #define DA8XX_TPTC1_BASE                0x01c08400
  34 #define DA8XX_WDOG_BASE                 0x01c21000 /* DA8XX_TIMER64P1_BASE */
  35 #define DA8XX_I2C0_BASE                 0x01c22000
  36 #define DA8XX_RTC_BASE                  0x01c23000
  37 #define DA8XX_PRUSS_MEM_BASE            0x01c30000
  38 #define DA8XX_MMCSD0_BASE               0x01c40000
  39 #define DA8XX_SPI0_BASE                 0x01c41000
  40 #define DA830_SPI1_BASE                 0x01e12000
  41 #define DA8XX_LCD_CNTRL_BASE            0x01e13000
  42 #define DA850_SATA_BASE                 0x01e18000
  43 #define DA850_MMCSD1_BASE               0x01e1b000
  44 #define DA8XX_EMAC_CPPI_PORT_BASE       0x01e20000
  45 #define DA8XX_EMAC_CPGMACSS_BASE        0x01e22000
  46 #define DA8XX_EMAC_CPGMAC_BASE          0x01e23000
  47 #define DA8XX_EMAC_MDIO_BASE            0x01e24000
  48 #define DA8XX_I2C1_BASE                 0x01e28000
  49 #define DA850_TPCC1_BASE                0x01e30000
  50 #define DA850_TPTC2_BASE                0x01e38000
  51 #define DA850_SPI1_BASE                 0x01f0e000
  52 #define DA8XX_DDR2_CTL_BASE             0xb0000000
  53
  54 #define DA8XX_EMAC_CTRL_REG_OFFSET      0x3000
  55 #define DA8XX_EMAC_MOD_REG_OFFSET       0x2000
  56 #define DA8XX_EMAC_RAM_OFFSET           0x0000
  57 #define DA8XX_EMAC_CTRL_RAM_SIZE        SZ_8K
  58
  59 #define DA8XX_DMA_SPI0_RX       EDMA_CTLR_CHAN(0, 14)
  60 #define DA8XX_DMA_SPI0_TX       EDMA_CTLR_CHAN(0, 15)
  61 #define DA8XX_DMA_MMCSD0_RX     EDMA_CTLR_CHAN(0, 16)
  62 #define DA8XX_DMA_MMCSD0_TX     EDMA_CTLR_CHAN(0, 17)
  63 #define DA8XX_DMA_SPI1_RX       EDMA_CTLR_CHAN(0, 18)
  64 #define DA8XX_DMA_SPI1_TX       EDMA_CTLR_CHAN(0, 19)
  65 #define DA850_DMA_MMCSD1_RX     EDMA_CTLR_CHAN(1, 28)
  66 #define DA850_DMA_MMCSD1_TX     EDMA_CTLR_CHAN(1, 29)
  67
  68 void __iomem *da8xx_syscfg0_base;
  69 void __iomem *da8xx_syscfg1_base;
  70
  71 static struct plat_serial8250_port da8xx_serial0_pdata[] = {
  72         {
  73                 .mapbase        = DA8XX_UART0_BASE,
  74                 .irq            = IRQ_DA8XX_UARTINT0,
  75                 .flags          = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST |
  76                                         UPF_IOREMAP,
  77                 .iotype         = UPIO_MEM,
  78                 .regshift       = 2,
  79         },
  80         {
  81                 .flags  = 0,
  82         }
  83 };
  84 static struct plat_serial8250_port da8xx_serial1_pdata[] = {
  85         {
  86                 .mapbase        = DA8XX_UART1_BASE,
  87                 .irq            = IRQ_DA8XX_UARTINT1,
  88                 .flags          = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST |
  89                                         UPF_IOREMAP,
  90                 .iotype         = UPIO_MEM,
  91                 .regshift       = 2,
  92         },
  93         {
  94                 .flags  = 0,
  95         }
  96 };
  97 static struct plat_serial8250_port da8xx_serial2_pdata[] = {
  98         {
  99                 .mapbase        = DA8XX_UART2_BASE,
 100                 .irq            = IRQ_DA8XX_UARTINT2,
 101                 .flags          = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST |
 102                                         UPF_IOREMAP,
 103                 .iotype         = UPIO_MEM,
 104                 .regshift       = 2,
 105         },
 106         {
 107                 .flags  = 0,
 108         }
 109 };
 110
 111 struct platform_device da8xx_serial_device[] = {
 112         {
 113                 .name   = "serial8250",
 114                 .id     = PLAT8250_DEV_PLATFORM,
 115                 .dev    = {
 116                         .platform_data  = da8xx_serial0_pdata,
 117                 }
 118         },
 119         {
 120                 .name   = "serial8250",
 121                 .id     = PLAT8250_DEV_PLATFORM1,
 122                 .dev    = {
 123                         .platform_data  = da8xx_serial1_pdata,
 124                 }
 125         },
 126         {
 127                 .name   = "serial8250",
 128                 .id     = PLAT8250_DEV_PLATFORM2,
 129                 .dev    = {
 130                         .platform_data  = da8xx_serial2_pdata,
 131                 }
 132         },
 133         {
 134         }
 135 };
 136
 137 static s8 da8xx_queue_priority_mapping[][2] = {
 138         /* {event queue no, Priority} */
 139         {0, 3},
 140         {1, 7},
 141         {-1, -1}
 142 };
 143
 144 static s8 da850_queue_priority_mapping[][2] = {
 145         /* {event queue no, Priority} */
 146         {0, 3},
 147         {-1, -1}
 148 };
 149
 150 static struct edma_soc_info da830_edma_cc0_info = {
 151         .queue_priority_mapping = da8xx_queue_priority_mapping,
 152         .default_queue          = EVENTQ_1,
 153 };
 154
 155 static struct edma_soc_info *da830_edma_info[EDMA_MAX_CC] = {
 156         &da830_edma_cc0_info,
 157 };
 158
 159 static struct edma_soc_info da850_edma_cc_info[] = {
 160         {
 161                 .queue_priority_mapping = da8xx_queue_priority_mapping,
 162                 .default_queue          = EVENTQ_1,
 163         },
 164         {
 165                 .queue_priority_mapping = da850_queue_priority_mapping,
 166                 .default_queue          = EVENTQ_0,
 167         },
 168 };
 169
 170 static struct edma_soc_info *da850_edma_info[EDMA_MAX_CC] = {
 171         &da850_edma_cc_info[0],
 172         &da850_edma_cc_info[1],
 173 };
 174
 175 static struct resource da830_edma_resources[] = {
 176         {
 177                 .name   = "edma_cc0",
 178                 .start  = DA8XX_TPCC_BASE,
 179                 .end    = DA8XX_TPCC_BASE + SZ_32K - 1,
 180                 .flags  = IORESOURCE_MEM,
 181         },
 182         {
 183                 .name   = "edma_tc0",
 184                 .start  = DA8XX_TPTC0_BASE,
 185                 .end    = DA8XX_TPTC0_BASE + SZ_1K - 1,
 186                 .flags  = IORESOURCE_MEM,
 187         },
 188         {
 189                 .name   = "edma_tc1",
 190                 .start  = DA8XX_TPTC1_BASE,
 191                 .end    = DA8XX_TPTC1_BASE + SZ_1K - 1,
 192                 .flags  = IORESOURCE_MEM,
 193         },
 194         {
 195                 .name   = "edma0",
 196                 .start  = IRQ_DA8XX_CCINT0,
 197                 .flags  = IORESOURCE_IRQ,
 198         },
 199         {
 200                 .name   = "edma0_err",
 201                 .start  = IRQ_DA8XX_CCERRINT,
 202                 .flags  = IORESOURCE_IRQ,
 203         },
 204 };
 205
 206 static struct resource da850_edma_resources[] = {
 207         {
 208                 .name   = "edma_cc0",
 209                 .start  = DA8XX_TPCC_BASE,
 210                 .end    = DA8XX_TPCC_BASE + SZ_32K - 1,
 211                 .flags  = IORESOURCE_MEM,
 212         },
 213         {
 214                 .name   = "edma_tc0",
 215                 .start  = DA8XX_TPTC0_BASE,
 216                 .end    = DA8XX_TPTC0_BASE + SZ_1K - 1,
 217                 .flags  = IORESOURCE_MEM,
 218         },
 219         {
 220                 .name   = "edma_tc1",
 221                 .start  = DA8XX_TPTC1_BASE,
 222                 .end    = DA8XX_TPTC1_BASE + SZ_1K - 1,
 223                 .flags  = IORESOURCE_MEM,
 224         },
 225         {
 226                 .name   = "edma_cc1",
 227                 .start  = DA850_TPCC1_BASE,
 228                 .end    = DA850_TPCC1_BASE + SZ_32K - 1,
 229                 .flags  = IORESOURCE_MEM,
 230         },
 231         {
 232                 .name   = "edma_tc2",
 233                 .start  = DA850_TPTC2_BASE,
 234                 .end    = DA850_TPTC2_BASE + SZ_1K - 1,
 235                 .flags  = IORESOURCE_MEM,
 236         },
 237         {
 238                 .name   = "edma0",
 239                 .start  = IRQ_DA8XX_CCINT0,
 240                 .flags  = IORESOURCE_IRQ,
 241         },
 242         {
 243                 .name   = "edma0_err",
 244                 .start  = IRQ_DA8XX_CCERRINT,
 245                 .flags  = IORESOURCE_IRQ,
 246         },
 247         {
 248                 .name   = "edma1",
 249                 .start  = IRQ_DA850_CCINT1,
 250                 .flags  = IORESOURCE_IRQ,
 251         },
 252         {
 253                 .name   = "edma1_err",
 254                 .start  = IRQ_DA850_CCERRINT1,
 255                 .flags  = IORESOURCE_IRQ,
 256         },
 257 };
 258
 259 static struct platform_device da830_edma_device = {
 260         .name           = "edma",
 261         .id             = -1,
 262         .dev = {
 263                 .platform_data = da830_edma_info,
 264         },
 265         .num_resources  = ARRAY_SIZE(da830_edma_resources),
 266         .resource       = da830_edma_resources,
 267 };
 268
 269 static struct platform_device da850_edma_device = {
 270         .name           = "edma",
 271         .id             = -1,
 272         .dev = {
 273                 .platform_data = da850_edma_info,
 274         },
 275         .num_resources  = ARRAY_SIZE(da850_edma_resources),
 276         .resource       = da850_edma_resources,
 277 };
 278
 279 int __init da830_register_edma(struct edma_rsv_info *rsv)
 280 {
 281         da830_edma_cc0_info.rsv = rsv;
 282
 283         return platform_device_register(&da830_edma_device);
 284 }
 285
 286 int __init da850_register_edma(struct edma_rsv_info *rsv[2])
 287 {
 288         if (rsv) {
 289                 da850_edma_cc_info[0].rsv = rsv[0];
 290                 da850_edma_cc_info[1].rsv = rsv[1];
 291         }
 292
 293         return platform_device_register(&da850_edma_device);
 294 }
 295
 296 static struct resource da8xx_i2c_resources0[] = {
 297         {
 298                 .start  = DA8XX_I2C0_BASE,
 299                 .end    = DA8XX_I2C0_BASE + SZ_4K - 1,
 300                 .flags  = IORESOURCE_MEM,
 301         },
 302         {
 303                 .start  = IRQ_DA8XX_I2CINT0,
 304                 .end    = IRQ_DA8XX_I2CINT0,
 305                 .flags  = IORESOURCE_IRQ,
 306         },
 307 };
 308
 309 static struct platform_device da8xx_i2c_device0 = {
 310         .name           = "i2c_davinci",
 311         .id             = 1,
 312         .num_resources  = ARRAY_SIZE(da8xx_i2c_resources0),
 313         .resource       = da8xx_i2c_resources0,
 314 };
 315
 316 static struct resource da8xx_i2c_resources1[] = {
 317         {
 318                 .start  = DA8XX_I2C1_BASE,
 319                 .end    = DA8XX_I2C1_BASE + SZ_4K - 1,
 320                 .flags  = IORESOURCE_MEM,
 321         },
 322         {
 323                 .start  = IRQ_DA8XX_I2CINT1,
 324                 .end    = IRQ_DA8XX_I2CINT1,
 325                 .flags  = IORESOURCE_IRQ,
 326         },
 327 };
 328
 329 static struct platform_device da8xx_i2c_device1 = {
 330         .name           = "i2c_davinci",
 331         .id             = 2,
 332         .num_resources  = ARRAY_SIZE(da8xx_i2c_resources1),
 333         .resource       = da8xx_i2c_resources1,
 334 };
 335
 336 int __init da8xx_register_i2c(int instance,
 337                 struct davinci_i2c_platform_data *pdata)
 338 {
 339         struct platform_device *pdev;
 340
 341         if (instance == 0)
 342                 pdev = &da8xx_i2c_device0;
 343         else if (instance == 1)
 344                 pdev = &da8xx_i2c_device1;
 345         else
 346                 return -EINVAL;
 347
 348         pdev->dev.platform_data = pdata;
 349         return platform_device_register(pdev);
 350 }
 351
 352 static struct resource da8xx_watchdog_resources[] = {
 353         {
 354                 .start  = DA8XX_WDOG_BASE,
 355                 .end    = DA8XX_WDOG_BASE + SZ_4K - 1,
 356                 .flags  = IORESOURCE_MEM,
 357         },
 358 };
 359
 360 static struct platform_device da8xx_wdt_device = {
 361         .name           = "davinci-wdt",
 362         .id             = -1,
 363         .num_resources  = ARRAY_SIZE(da8xx_watchdog_resources),
 364         .resource       = da8xx_watchdog_resources,
 365 };
 366
 367 void da8xx_restart(enum reboot_mode mode, const char *cmd)
 368 {
 369         struct device *dev;
 370
 371         dev = bus_find_device_by_name(&platform_bus_type, NULL, "davinci-wdt");
 372         if (!dev) {
 373                 pr_err("%s: failed to find watchdog device\n", __func__);
 374                 return;
 375         }
 376
 377         davinci_watchdog_reset(to_platform_device(dev));
 378 }
 379
 380 int __init da8xx_register_watchdog(void)
 381 {
 382         return platform_device_register(&da8xx_wdt_device);
 383 }
 384
 385 static struct resource da8xx_emac_resources[] = {
 386         {
 387                 .start  = DA8XX_EMAC_CPPI_PORT_BASE,
 388                 .end    = DA8XX_EMAC_CPPI_PORT_BASE + SZ_16K - 1,
 389                 .flags  = IORESOURCE_MEM,
 390         },
 391         {
 392                 .start  = IRQ_DA8XX_C0_RX_THRESH_PULSE,
 393                 .end    = IRQ_DA8XX_C0_RX_THRESH_PULSE,
 394                 .flags  = IORESOURCE_IRQ,
 395         },
 396         {
 397                 .start  = IRQ_DA8XX_C0_RX_PULSE,
 398                 .end    = IRQ_DA8XX_C0_RX_PULSE,
 399                 .flags  = IORESOURCE_IRQ,
 400         },
 401         {
 402                 .start  = IRQ_DA8XX_C0_TX_PULSE,
 403                 .end    = IRQ_DA8XX_C0_TX_PULSE,
 404                 .flags  = IORESOURCE_IRQ,
 405         },
 406         {
 407                 .start  = IRQ_DA8XX_C0_MISC_PULSE,
 408                 .end    = IRQ_DA8XX_C0_MISC_PULSE,
 409                 .flags  = IORESOURCE_IRQ,
 410         },
 411 };
 412
 413 struct emac_platform_data da8xx_emac_pdata = {
 414         .ctrl_reg_offset        = DA8XX_EMAC_CTRL_REG_OFFSET,
 415         .ctrl_mod_reg_offset    = DA8XX_EMAC_MOD_REG_OFFSET,
 416         .ctrl_ram_offset        = DA8XX_EMAC_RAM_OFFSET,
 417         .ctrl_ram_size          = DA8XX_EMAC_CTRL_RAM_SIZE,
 418         .version                = EMAC_VERSION_2,
 419 };
 420
 421 static struct platform_device da8xx_emac_device = {
 422         .name           = "davinci_emac",
 423         .id             = 1,
 424         .dev = {
 425                 .platform_data  = &da8xx_emac_pdata,
 426         },
 427         .num_resources  = ARRAY_SIZE(da8xx_emac_resources),
 428         .resource       = da8xx_emac_resources,
 429 };
 430
 431 static struct resource da8xx_mdio_resources[] = {
 432         {
 433                 .start  = DA8XX_EMAC_MDIO_BASE,
 434                 .end    = DA8XX_EMAC_MDIO_BASE + SZ_4K - 1,
 435                 .flags  = IORESOURCE_MEM,
 436         },
 437 };
 438
 439 static struct platform_device da8xx_mdio_device = {
 440         .name           = "davinci_mdio",
 441         .id             = 0,
 442         .num_resources  = ARRAY_SIZE(da8xx_mdio_resources),
 443         .resource       = da8xx_mdio_resources,
 444 };
 445
 446 int __init da8xx_register_emac(void)
 447 {
 448         int ret;
 449
 450         ret = platform_device_register(&da8xx_mdio_device);
 451         if (ret < 0)
 452                 return ret;
 453
 454         return platform_device_register(&da8xx_emac_device);
 455 }
 456
 457 static struct resource da830_mcasp1_resources[] = {
 458         {
 459                 .name   = "mpu",
 460                 .start  = DAVINCI_DA830_MCASP1_REG_BASE,
 461                 .end    = DAVINCI_DA830_MCASP1_REG_BASE + (SZ_1K * 12) - 1,
 462                 .flags  = IORESOURCE_MEM,
 463         },
 464         /* TX event */
 465         {
 466                 .name   = "tx",
 467                 .start  = DAVINCI_DA830_DMA_MCASP1_AXEVT,
 468                 .end    = DAVINCI_DA830_DMA_MCASP1_AXEVT,
 469                 .flags  = IORESOURCE_DMA,
 470         },
 471         /* RX event */
 472         {
 473                 .name   = "rx",
 474                 .start  = DAVINCI_DA830_DMA_MCASP1_AREVT,
 475                 .end    = DAVINCI_DA830_DMA_MCASP1_AREVT,
 476                 .flags  = IORESOURCE_DMA,
 477         },
 478         {
 479                 .name   = "common",
 480                 .start  = IRQ_DA8XX_MCASPINT,
 481                 .flags  = IORESOURCE_IRQ,
 482         },
 483 };
 484
 485 static struct platform_device da830_mcasp1_device = {
 486         .name           = "davinci-mcasp",
 487         .id             = 1,
 488         .num_resources  = ARRAY_SIZE(da830_mcasp1_resources),
 489         .resource       = da830_mcasp1_resources,
 490 };
 491
 492 static struct resource da830_mcasp2_resources[] = {
 493         {
 494                 .name   = "mpu",
 495                 .start  = DAVINCI_DA830_MCASP2_REG_BASE,
 496                 .end    = DAVINCI_DA830_MCASP2_REG_BASE + (SZ_1K * 12) - 1,
 497                 .flags  = IORESOURCE_MEM,
 498         },
 499         /* TX event */
 500         {
 501                 .name   = "tx",
 502                 .start  = DAVINCI_DA830_DMA_MCASP2_AXEVT,
 503                 .end    = DAVINCI_DA830_DMA_MCASP2_AXEVT,
 504                 .flags  = IORESOURCE_DMA,
 505         },
 506         /* RX event */
 507         {
 508                 .name   = "rx",
 509                 .start  = DAVINCI_DA830_DMA_MCASP2_AREVT,
 510                 .end    = DAVINCI_DA830_DMA_MCASP2_AREVT,
 511                 .flags  = IORESOURCE_DMA,
 512         },
 513         {
 514                 .name   = "common",
 515                 .start  = IRQ_DA8XX_MCASPINT,
 516                 .flags  = IORESOURCE_IRQ,
 517         },
 518 };
 519
 520 static struct platform_device da830_mcasp2_device = {
 521         .name           = "davinci-mcasp",
 522         .id             = 2,
 523         .num_resources  = ARRAY_SIZE(da830_mcasp2_resources),
 524         .resource       = da830_mcasp2_resources,
 525 };
 526
 527 static struct resource da850_mcasp_resources[] = {
 528         {
 529                 .name   = "mpu",
 530                 .start  = DAVINCI_DA8XX_MCASP0_REG_BASE,
 531                 .end    = DAVINCI_DA8XX_MCASP0_REG_BASE + (SZ_1K * 12) - 1,
 532                 .flags  = IORESOURCE_MEM,
 533         },
 534         /* TX event */
 535         {
 536                 .name   = "tx",
 537                 .start  = DAVINCI_DA8XX_DMA_MCASP0_AXEVT,
 538                 .end    = DAVINCI_DA8XX_DMA_MCASP0_AXEVT,
 539                 .flags  = IORESOURCE_DMA,
 540         },
 541         /* RX event */
 542         {
 543                 .name   = "rx",
 544                 .start  = DAVINCI_DA8XX_DMA_MCASP0_AREVT,
 545                 .end    = DAVINCI_DA8XX_DMA_MCASP0_AREVT,
 546                 .flags  = IORESOURCE_DMA,
 547         },
 548         {
 549                 .name   = "common",
 550                 .start  = IRQ_DA8XX_MCASPINT,
 551                 .flags  = IORESOURCE_IRQ,
 552         },
 553 };
 554
 555 static struct platform_device da850_mcasp_device = {
 556         .name           = "davinci-mcasp",
 557         .id             = 0,
 558         .num_resources  = ARRAY_SIZE(da850_mcasp_resources),
 559         .resource       = da850_mcasp_resources,
 560 };
 561
 562 void __init da8xx_register_mcasp(int id, struct snd_platform_data *pdata)
 563 {
 564         struct platform_device *pdev;
 565
 566         switch (id) {
 567         case 0:
 568                 /* Valid for DA830/OMAP-L137 or DA850/OMAP-L138 */
 569                 pdev = &da850_mcasp_device;
 570                 break;
 571         case 1:
 572                 /* Valid for DA830/OMAP-L137 only */
 573                 if (!cpu_is_davinci_da830())
 574                         return;
 575                 pdev = &da830_mcasp1_device;
 576                 break;
 577         case 2:
 578                 /* Valid for DA830/OMAP-L137 only */
 579                 if (!cpu_is_davinci_da830())
 580                         return;
 581                 pdev = &da830_mcasp2_device;
 582                 break;
 583         default:
 584                 return;
 585         }
 586
 587         pdev->dev.platform_data = pdata;
 588         platform_device_register(pdev);
 589 }
 590
 591 static struct resource da8xx_pruss_resources[] = {
 592         {
 593                 .start  = DA8XX_PRUSS_MEM_BASE,
 594                 .end    = DA8XX_PRUSS_MEM_BASE + 0xFFFF,
 595                 .flags  = IORESOURCE_MEM,
 596         },
 597         {
 598                 .start  = IRQ_DA8XX_EVTOUT0,
 599                 .end    = IRQ_DA8XX_EVTOUT0,
 600                 .flags  = IORESOURCE_IRQ,
 601         },
 602         {
 603                 .start  = IRQ_DA8XX_EVTOUT1,
 604                 .end    = IRQ_DA8XX_EVTOUT1,
 605                 .flags  = IORESOURCE_IRQ,
 606         },
 607         {
 608                 .start  = IRQ_DA8XX_EVTOUT2,
 609                 .end    = IRQ_DA8XX_EVTOUT2,
 610                 .flags  = IORESOURCE_IRQ,
 611         },
 612         {
 613                 .start  = IRQ_DA8XX_EVTOUT3,
 614                 .end    = IRQ_DA8XX_EVTOUT3,
 615                 .flags  = IORESOURCE_IRQ,
 616         },
 617         {
 618                 .start  = IRQ_DA8XX_EVTOUT4,
 619                 .end    = IRQ_DA8XX_EVTOUT4,
 620                 .flags  = IORESOURCE_IRQ,
 621         },
 622         {
 623                 .start  = IRQ_DA8XX_EVTOUT5,
 624                 .end    = IRQ_DA8XX_EVTOUT5,
 625                 .flags  = IORESOURCE_IRQ,
 626         },
 627         {
 628                 .start  = IRQ_DA8XX_EVTOUT6,
 629                 .end    = IRQ_DA8XX_EVTOUT6,
 630                 .flags  = IORESOURCE_IRQ,
 631         },
 632         {
 633                 .start  = IRQ_DA8XX_EVTOUT7,
 634                 .end    = IRQ_DA8XX_EVTOUT7,
 635                 .flags  = IORESOURCE_IRQ,
 636         },
 637 };
 638
 639 static struct uio_pruss_pdata da8xx_uio_pruss_pdata = {
 640         .pintc_base     = 0x4000,
 641 };
 642
 643 static struct platform_device da8xx_uio_pruss_dev = {
 644         .name           = "pruss_uio",
 645         .id             = -1,
 646         .num_resources  = ARRAY_SIZE(da8xx_pruss_resources),
 647         .resource       = da8xx_pruss_resources,
 648         .dev            = {
 649                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 650                 .platform_data          = &da8xx_uio_pruss_pdata,
 651         }
 652 };
 653
 654 int __init da8xx_register_uio_pruss(void)
 655 {
 656         da8xx_uio_pruss_pdata.sram_pool = sram_get_gen_pool();
 657         return platform_device_register(&da8xx_uio_pruss_dev);
 658 }
 659
 660 static struct lcd_ctrl_config lcd_cfg = {
 661         .panel_shade            = COLOR_ACTIVE,
 662         .bpp                    = 16,
 663 };
 664
 665 struct da8xx_lcdc_platform_data sharp_lcd035q3dg01_pdata = {
 666         .manu_name              = "sharp",
 667         .controller_data        = &lcd_cfg,
 668         .type                   = "Sharp_LCD035Q3DG01",
 669 };
 670
 671 struct da8xx_lcdc_platform_data sharp_lk043t1dg01_pdata = {
 672         .manu_name              = "sharp",
 673         .controller_data        = &lcd_cfg,
 674         .type                   = "Sharp_LK043T1DG01",
 675 };
 676
 677 static struct resource da8xx_lcdc_resources[] = {
 678         [0] = { /* registers */
 679                 .start  = DA8XX_LCD_CNTRL_BASE,
 680                 .end    = DA8XX_LCD_CNTRL_BASE + SZ_4K - 1,
 681                 .flags  = IORESOURCE_MEM,
 682         },
 683         [1] = { /* interrupt */
 684                 .start  = IRQ_DA8XX_LCDINT,
 685                 .end    = IRQ_DA8XX_LCDINT,
 686                 .flags  = IORESOURCE_IRQ,
 687         },
 688 };
 689
 690 static struct platform_device da8xx_lcdc_device = {
 691         .name           = "da8xx_lcdc",
 692         .id             = 0,
 693         .num_resources  = ARRAY_SIZE(da8xx_lcdc_resources),
 694         .resource       = da8xx_lcdc_resources,
 695 };
 696
 697 int __init da8xx_register_lcdc(struct da8xx_lcdc_platform_data *pdata)
 698 {
 699         da8xx_lcdc_device.dev.platform_data = pdata;
 700         return platform_device_register(&da8xx_lcdc_device);
 701 }
 702
 703 static struct resource da8xx_gpio_resources[] = {
 704         { /* registers */
 705                 .start  = DA8XX_GPIO_BASE,
 706                 .end    = DA8XX_GPIO_BASE + SZ_4K - 1,
 707                 .flags  = IORESOURCE_MEM,
 708         },
 709         { /* interrupt */
 710                 .start  = IRQ_DA8XX_GPIO0,
 711                 .end    = IRQ_DA8XX_GPIO8,
 712                 .flags  = IORESOURCE_IRQ,
 713         },
 714 };
 715
 716 static struct platform_device da8xx_gpio_device = {
 717         .name           = "davinci_gpio",
 718         .id             = -1,
 719         .num_resources  = ARRAY_SIZE(da8xx_gpio_resources),
 720         .resource       = da8xx_gpio_resources,
 721 };
 722
 723 int __init da8xx_register_gpio(void *pdata)
 724 {
 725         da8xx_gpio_device.dev.platform_data = pdata;
 726         return platform_device_register(&da8xx_gpio_device);
 727 }
 728
 729 static struct resource da8xx_mmcsd0_resources[] = {
 730         {               /* registers */
 731                 .start  = DA8XX_MMCSD0_BASE,
 732                 .end    = DA8XX_MMCSD0_BASE + SZ_4K - 1,
 733                 .flags  = IORESOURCE_MEM,
 734         },
 735         {               /* interrupt */
 736                 .start  = IRQ_DA8XX_MMCSDINT0,
 737                 .end    = IRQ_DA8XX_MMCSDINT0,
 738                 .flags  = IORESOURCE_IRQ,
 739         },
 740         {               /* DMA RX */
 741                 .start  = DA8XX_DMA_MMCSD0_RX,
 742                 .end    = DA8XX_DMA_MMCSD0_RX,
 743                 .flags  = IORESOURCE_DMA,
 744         },
 745         {               /* DMA TX */
 746                 .start  = DA8XX_DMA_MMCSD0_TX,
 747                 .end    = DA8XX_DMA_MMCSD0_TX,
 748                 .flags  = IORESOURCE_DMA,
 749         },
 750 };
 751
 752 static struct platform_device da8xx_mmcsd0_device = {
 753         .name           = "da830-mmc",
 754         .id             = 0,
 755         .num_resources  = ARRAY_SIZE(da8xx_mmcsd0_resources),
 756         .resource       = da8xx_mmcsd0_resources,
 757 };
 758
 759 int __init da8xx_register_mmcsd0(struct davinci_mmc_config *config)
 760 {
 761         da8xx_mmcsd0_device.dev.platform_data = config;
 762         return platform_device_register(&da8xx_mmcsd0_device);
 763 }
 764
 765 #ifdef CONFIG_ARCH_DAVINCI_DA850
 766 static struct resource da850_mmcsd1_resources[] = {
 767         {               /* registers */
 768                 .start  = DA850_MMCSD1_BASE,
 769                 .end    = DA850_MMCSD1_BASE + SZ_4K - 1,
 770                 .flags  = IORESOURCE_MEM,
 771         },
 772         {               /* interrupt */
 773                 .start  = IRQ_DA850_MMCSDINT0_1,
 774                 .end    = IRQ_DA850_MMCSDINT0_1,
 775                 .flags  = IORESOURCE_IRQ,
 776         },
 777         {               /* DMA RX */
 778                 .start  = DA850_DMA_MMCSD1_RX,
 779                 .end    = DA850_DMA_MMCSD1_RX,
 780                 .flags  = IORESOURCE_DMA,
 781         },
 782         {               /* DMA TX */
 783                 .start  = DA850_DMA_MMCSD1_TX,
 784                 .end    = DA850_DMA_MMCSD1_TX,
 785                 .flags  = IORESOURCE_DMA,
 786         },
 787 };
 788
 789 static struct platform_device da850_mmcsd1_device = {
 790         .name           = "da830-mmc",
 791         .id             = 1,
 792         .num_resources  = ARRAY_SIZE(da850_mmcsd1_resources),
 793         .resource       = da850_mmcsd1_resources,
 794 };
 795
 796 int __init da850_register_mmcsd1(struct davinci_mmc_config *config)
 797 {
 798         da850_mmcsd1_device.dev.platform_data = config;
 799         return platform_device_register(&da850_mmcsd1_device);
 800 }
 801 #endif
 802
 803 static struct resource da8xx_rproc_resources[] = {
 804         { /* DSP boot address */
 805                 .start          = DA8XX_SYSCFG0_BASE + DA8XX_HOST1CFG_REG,
 806                 .end            = DA8XX_SYSCFG0_BASE + DA8XX_HOST1CFG_REG + 3,
 807                 .flags          = IORESOURCE_MEM,
 808         },
 809         { /* DSP interrupt registers */
 810                 .start          = DA8XX_SYSCFG0_BASE + DA8XX_CHIPSIG_REG,
 811                 .end            = DA8XX_SYSCFG0_BASE + DA8XX_CHIPSIG_REG + 7,
 812                 .flags          = IORESOURCE_MEM,
 813         },
 814         { /* dsp irq */
 815                 .start          = IRQ_DA8XX_CHIPINT0,
 816                 .end            = IRQ_DA8XX_CHIPINT0,
 817                 .flags          = IORESOURCE_IRQ,
 818         },
 819 };
 820
 821 static struct platform_device da8xx_dsp = {
 822         .name   = "davinci-rproc",
 823         .dev    = {
 824                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 825         },
 826         .num_resources  = ARRAY_SIZE(da8xx_rproc_resources),
 827         .resource       = da8xx_rproc_resources,
 828 };
 829
 830 #if IS_ENABLED(CONFIG_DA8XX_REMOTEPROC)
 831
 832 static phys_addr_t rproc_base __initdata;
 833 static unsigned long rproc_size __initdata;
 834
 835 static int __init early_rproc_mem(char *p)
 836 {
 837         char *endp;
 838
 839         if (p == NULL)
 840                 return 0;
 841
 842         rproc_size = memparse(p, &endp);
 843         if (*endp == '@')
 844                 rproc_base = memparse(endp + 1, NULL);
 845
 846         return 0;
 847 }
 848 early_param("rproc_mem", early_rproc_mem);
 849
 850 void __init da8xx_rproc_reserve_cma(void)
 851 {
 852         int ret;
 853
 854         if (!rproc_base || !rproc_size) {
 855                 pr_err("%s: 'rproc_mem=nn@address' badly specified\n"
 856                        "    'nn' and 'address' must both be non-zero\n",
 857                        __func__);
 858
 859                 return;
 860         }
 861
 862         pr_info("%s: reserving 0x%lx @ 0x%lx...\n",
 863                 __func__, rproc_size, (unsigned long)rproc_base);
 864
 865         ret = dma_declare_contiguous(&da8xx_dsp.dev, rproc_size, rproc_base, 0);
 866         if (ret)
 867                 pr_err("%s: dma_declare_contiguous failed %d\n", __func__, ret);
 868 }
 869
 870 #else
 871
 872 void __init da8xx_rproc_reserve_cma(void)
 873 {
 874 }
 875
 876 #endif
 877
 878 int __init da8xx_register_rproc(void)
 879 {
 880         int ret;
 881
 882         ret = platform_device_register(&da8xx_dsp);
 883         if (ret)
 884                 pr_err("%s: can't register DSP device: %d\n", __func__, ret);
 885
 886         return ret;
 887 };
 888
 889 static struct resource da8xx_rtc_resources[] = {
 890         {
 891                 .start          = DA8XX_RTC_BASE,
 892                 .end            = DA8XX_RTC_BASE + SZ_4K - 1,
 893                 .flags          = IORESOURCE_MEM,
 894         },
 895         { /* timer irq */
 896                 .start          = IRQ_DA8XX_RTC,
 897                 .end            = IRQ_DA8XX_RTC,
 898                 .flags          = IORESOURCE_IRQ,
 899         },
 900         { /* alarm irq */
 901                 .start          = IRQ_DA8XX_RTC,
 902                 .end            = IRQ_DA8XX_RTC,
 903                 .flags          = IORESOURCE_IRQ,
 904         },
 905 };
 906
 907 static struct platform_device da8xx_rtc_device = {
 908         .name           = "da830-rtc",
 909         .id             = -1,
 910         .num_resources  = ARRAY_SIZE(da8xx_rtc_resources),
 911         .resource       = da8xx_rtc_resources,
 912 };
 913
 914 int da8xx_register_rtc(void)
 915 {
 916         return platform_device_register(&da8xx_rtc_device);
 917 }
 918
 919 static void __iomem *da8xx_ddr2_ctlr_base;
 920 void __iomem * __init da8xx_get_mem_ctlr(void)
 921 {
 922         if (da8xx_ddr2_ctlr_base)
 923                 return da8xx_ddr2_ctlr_base;
 924
 925         da8xx_ddr2_ctlr_base = ioremap(DA8XX_DDR2_CTL_BASE, SZ_32K);
 926         if (!da8xx_ddr2_ctlr_base)
 927                 pr_warn("%s: Unable to map DDR2 controller", __func__);
 928
 929         return da8xx_ddr2_ctlr_base;
 930 }
 931
 932 static struct resource da8xx_cpuidle_resources[] = {
 933         {
 934                 .start          = DA8XX_DDR2_CTL_BASE,
 935                 .end            = DA8XX_DDR2_CTL_BASE + SZ_32K - 1,
 936                 .flags          = IORESOURCE_MEM,
 937         },
 938 };
 939
 940 /* DA8XX devices support DDR2 power down */
 941 static struct davinci_cpuidle_config da8xx_cpuidle_pdata = {
 942         .ddr2_pdown     = 1,
 943 };
 944
 945
 946 static struct platform_device da8xx_cpuidle_device = {
 947         .name                   = "cpuidle-davinci",
 948         .num_resources          = ARRAY_SIZE(da8xx_cpuidle_resources),
 949         .resource               = da8xx_cpuidle_resources,
 950         .dev = {
 951                 .platform_data  = &da8xx_cpuidle_pdata,
 952         },
 953 };
 954
 955 int __init da8xx_register_cpuidle(void)
 956 {
 957         da8xx_cpuidle_pdata.ddr2_ctlr_base = da8xx_get_mem_ctlr();
 958
 959         return platform_device_register(&da8xx_cpuidle_device);
 960 }
 961
 962 static struct resource da8xx_spi0_resources[] = {
 963         [0] = {
 964                 .start  = DA8XX_SPI0_BASE,
 965                 .end    = DA8XX_SPI0_BASE + SZ_4K - 1,
 966                 .flags  = IORESOURCE_MEM,
 967         },
 968         [1] = {
 969                 .start  = IRQ_DA8XX_SPINT0,
 970                 .end    = IRQ_DA8XX_SPINT0,
 971                 .flags  = IORESOURCE_IRQ,
 972         },
 973         [2] = {
 974                 .start  = DA8XX_DMA_SPI0_RX,
 975                 .end    = DA8XX_DMA_SPI0_RX,
 976                 .flags  = IORESOURCE_DMA,
 977         },
 978         [3] = {
 979                 .start  = DA8XX_DMA_SPI0_TX,
 980                 .end    = DA8XX_DMA_SPI0_TX,
 981                 .flags  = IORESOURCE_DMA,
 982         },
 983 };
 984
 985 static struct resource da8xx_spi1_resources[] = {
 986         [0] = {
 987                 .start  = DA830_SPI1_BASE,
 988                 .end    = DA830_SPI1_BASE + SZ_4K - 1,
 989                 .flags  = IORESOURCE_MEM,
 990         },
 991         [1] = {
 992                 .start  = IRQ_DA8XX_SPINT1,
 993                 .end    = IRQ_DA8XX_SPINT1,
 994                 .flags  = IORESOURCE_IRQ,
 995         },
 996         [2] = {
 997                 .start  = DA8XX_DMA_SPI1_RX,
 998                 .end    = DA8XX_DMA_SPI1_RX,
 999                 .flags  = IORESOURCE_DMA,
1000         },
1001         [3] = {
1002                 .start  = DA8XX_DMA_SPI1_TX,
1003                 .end    = DA8XX_DMA_SPI1_TX,
1004                 .flags  = IORESOURCE_DMA,
1005         },
1006 };
1007
1008 static struct davinci_spi_platform_data da8xx_spi_pdata[] = {
1009         [0] = {
1010                 .version        = SPI_VERSION_2,
1011                 .intr_line      = 1,
1012                 .dma_event_q    = EVENTQ_0,
1013                 .prescaler_limit = 2,
1014         },
1015         [1] = {
1016                 .version        = SPI_VERSION_2,
1017                 .intr_line      = 1,
1018                 .dma_event_q    = EVENTQ_0,
1019                 .prescaler_limit = 2,
1020         },
1021 };
1022
1023 static struct platform_device da8xx_spi_device[] = {
1024         [0] = {
1025                 .name           = "spi_davinci",
1026                 .id             = 0,
1027                 .num_resources  = ARRAY_SIZE(da8xx_spi0_resources),
1028                 .resource       = da8xx_spi0_resources,
1029                 .dev            = {
1030                         .platform_data = &da8xx_spi_pdata[0],
1031                 },
1032         },
1033         [1] = {
1034                 .name           = "spi_davinci",
1035                 .id             = 1,
1036                 .num_resources  = ARRAY_SIZE(da8xx_spi1_resources),
1037                 .resource       = da8xx_spi1_resources,
1038                 .dev            = {
1039                         .platform_data = &da8xx_spi_pdata[1],
1040                 },
1041         },
1042 };
1043
1044 int __init da8xx_register_spi_bus(int instance, unsigned num_chipselect)
1045 {
1046         if (instance < 0 || instance > 1)
1047                 return -EINVAL;
1048
1049         da8xx_spi_pdata[instance].num_chipselect = num_chipselect;
1050
1051         if (instance == 1 && cpu_is_davinci_da850()) {
1052                 da8xx_spi1_resources[0].start = DA850_SPI1_BASE;
1053                 da8xx_spi1_resources[0].end = DA850_SPI1_BASE + SZ_4K - 1;
1054         }
1055
1056         return platform_device_register(&da8xx_spi_device[instance]);
1057 }
1058
1059 #ifdef CONFIG_ARCH_DAVINCI_DA850
1060 static struct resource da850_sata_resources[] = {
1061         {
1062                 .start  = DA850_SATA_BASE,
1063                 .end    = DA850_SATA_BASE + 0x1fff,
1064                 .flags  = IORESOURCE_MEM,
1065         },
1066         {
1067                 .start  = DA8XX_SYSCFG1_BASE + DA8XX_PWRDN_REG,
1068                 .end    = DA8XX_SYSCFG1_BASE + DA8XX_PWRDN_REG + 0x3,
1069                 .flags  = IORESOURCE_MEM,
1070         },
1071         {
1072                 .start  = IRQ_DA850_SATAINT,
1073                 .flags  = IORESOURCE_IRQ,
1074         },
1075 };
1076
1077 static u64 da850_sata_dmamask = DMA_BIT_MASK(32);
1078
1079 static struct platform_device da850_sata_device = {
1080         .name   = "ahci_da850",
1081         .id     = -1,
1082         .dev    = {
1083                 .dma_mask               = &da850_sata_dmamask,
1084                 .coherent_dma_mask      = DMA_BIT_MASK(32),
1085         },
1086         .num_resources  = ARRAY_SIZE(da850_sata_resources),
1087         .resource       = da850_sata_resources,
1088 };
1089
1090 int __init da850_register_sata(unsigned long refclkpn)
1091 {
1092         /* please see comment in drivers/ata/ahci_da850.c */
1093         BUG_ON(refclkpn != 100 * 1000 * 1000);
1094
1095         return platform_device_register(&da850_sata_device);
1096 }
1097 #endif