devices.c

   1 /* arch/arm/mach-rk30/devices.c
   2  *
   3  * Copyright (C) 2012 ROCKCHIP, Inc.
   4  *
   5  * This software is licensed under the terms of the GNU General Public
   6  * License version 2, as published by the Free Software Foundation, and
   7  * may be copied, distributed, and modified under those terms.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  */
  15
  16 #include <linux/fs.h>
  17 #include <linux/kernel.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/delay.h>
  20 #include <linux/dma-mapping.h>
  21 #include <asm/pmu.h>
  22 #include <mach/irqs.h>
  23 #include <mach/board.h>
  24 #include <plat/dma-pl330.h>
  25 #include <mach/gpio.h>
  26 #include <mach/iomux.h>
  27 #include <mach/debug_uart.h>
  28 #include <plat/rk_fiq_debugger.h>
  29
  30 #ifdef CONFIG_ADC_RK30
  31 static struct adc_platform_data rk30_adc_pdata = {
  32         #if defined(CONFIG_ARCH_RK3066B) || defined(CONFIG_ARCH_RK3188)
  33         .ref_volt = 1800, //1800mV
  34         #else
  35         .ref_volt = 2500, //2500mV
  36         #endif
  37         .base_chn = -1,
  38 };
  39 static struct resource rk30_adc_resource[] = {
  40         {
  41                 .start  = IRQ_SARADC,
  42                 .end    = IRQ_SARADC,
  43                 .flags  = IORESOURCE_IRQ,
  44         },
  45         {
  46                 .start  = RK30_SARADC_PHYS,
  47                 .end    = RK30_SARADC_PHYS + RK30_SARADC_SIZE - 1,
  48                 .flags  = IORESOURCE_MEM,
  49         },
  50 };
  51
  52 struct platform_device device_adc = {
  53         .name           = "rk30-adc",
  54         .id             = -1,
  55         .num_resources  = ARRAY_SIZE(rk30_adc_resource),
  56         .resource       = rk30_adc_resource,
  57         .dev            = {
  58                 .platform_data = &rk30_adc_pdata,
  59         },
  60 };
  61 #endif
  62
  63 #if !defined(CONFIG_ARCH_RK3066B) && defined(IRQ_TSADC)
  64 static struct resource rk30_tsadc_resource[] = {
  65         {
  66                 .start  = IRQ_TSADC,
  67                 .end    = IRQ_TSADC,
  68                 .flags  = IORESOURCE_IRQ,
  69         },
  70         {
  71                 .start  = RK30_TSADC_PHYS,
  72                 .end    = RK30_TSADC_PHYS + RK30_TSADC_SIZE - 1,
  73                 .flags  = IORESOURCE_MEM,
  74         },
  75 };
  76
  77 static struct platform_device device_tsadc = {
  78         .name           = "rk30-tsadc",
  79         .id             = -1,
  80         .num_resources  = ARRAY_SIZE(rk30_tsadc_resource),
  81         .resource       = rk30_tsadc_resource,
  82 };
  83
  84 static void __init rk30_init_tsadc(void)
  85 {
  86         platform_device_register(&device_tsadc);
  87 }
  88 #else
  89 static void __init rk30_init_tsadc(void) {}
  90 #endif
  91
  92 static u64 dma_dmamask = DMA_BIT_MASK(32);
  93
  94 static struct resource resource_dmac1[] = {
  95         [0] = {
  96                 .start  = RK30_DMACS1_PHYS,
  97                 .end    = RK30_DMACS1_PHYS + RK30_DMACS1_SIZE -1,
  98                 .flags  = IORESOURCE_MEM,
  99         },
 100         [1] = {
 101                 .start  = IRQ_DMAC1_0,
 102                 .end    = IRQ_DMAC1_1,
 103                 .flags  = IORESOURCE_IRQ,
 104         },
 105 };
 106
 107 #if defined(CONFIG_ARCH_RK3066B) || defined(CONFIG_ARCH_RK3188)
 108
 109 static struct rk29_pl330_platdata dmac1_pdata = {
 110         .peri = {
 111                 [0] = DMACH_UART0_TX,
 112                 [1] = DMACH_UART0_RX,
 113                 [2] = DMACH_UART1_TX,
 114                 [3] = DMACH_UART1_RX,
 115                 [4] = DMACH_MAX,
 116                 [5] = DMACH_MAX,
 117                 [6] = DMACH_I2S1_2CH_TX,
 118                 [7] = DMACH_I2S1_2CH_RX,
 119                 [8] = DMACH_SPDIF_TX,
 120                 [9] = DMACH_DMAC0_MEMTOMEM,
 121                 [10] = DMACH_MAX,
 122                 [11] = DMACH_MAX,
 123                 [12] = DMACH_MAX,
 124                 [13] = DMACH_MAX,
 125                 [14] = DMACH_MAX,
 126                 [15] = DMACH_MAX,
 127                 [16] = DMACH_MAX,
 128                 [17] = DMACH_MAX,
 129                 [18] = DMACH_MAX,
 130                 [19] = DMACH_MAX,
 131                 [20] = DMACH_MAX,
 132                 [21] = DMACH_MAX,
 133                 [22] = DMACH_MAX,
 134                 [23] = DMACH_MAX,
 135                 [24] = DMACH_MAX,
 136                 [25] = DMACH_MAX,
 137                 [26] = DMACH_MAX,
 138                 [27] = DMACH_MAX,
 139                 [28] = DMACH_MAX,
 140                 [29] = DMACH_MAX,
 141                 [30] = DMACH_MAX,
 142                 [31] = DMACH_MAX,
 143         },
 144 };
 145
 146 #else
 147
 148 static struct rk29_pl330_platdata dmac1_pdata = {
 149         .peri = {
 150                 [0] = DMACH_UART0_TX,
 151                 [1] = DMACH_UART0_RX,
 152                 [2] = DMACH_UART1_TX,
 153                 [3] = DMACH_UART1_RX,
 154                 [4] = DMACH_I2S0_8CH_TX,
 155                 [5] = DMACH_I2S0_8CH_RX,
 156                 [6] = DMACH_I2S1_2CH_TX,
 157                 [7] = DMACH_I2S1_2CH_RX,
 158                 [8] = DMACH_SPDIF_TX,
 159                 [9] = DMACH_I2S2_2CH_TX,
 160                 [10] = DMACH_I2S2_2CH_RX,
 161                 [11] = DMACH_DMAC0_MEMTOMEM,
 162                 [12] = DMACH_MAX,
 163                 [13] = DMACH_MAX,
 164                 [14] = DMACH_MAX,
 165                 [15] = DMACH_MAX,
 166                 [16] = DMACH_MAX,
 167                 [17] = DMACH_MAX,
 168                 [18] = DMACH_MAX,
 169                 [19] = DMACH_MAX,
 170                 [20] = DMACH_MAX,
 171                 [21] = DMACH_MAX,
 172                 [22] = DMACH_MAX,
 173                 [23] = DMACH_MAX,
 174                 [24] = DMACH_MAX,
 175                 [25] = DMACH_MAX,
 176                 [26] = DMACH_MAX,
 177                 [27] = DMACH_MAX,
 178                 [28] = DMACH_MAX,
 179                 [29] = DMACH_MAX,
 180                 [30] = DMACH_MAX,
 181                 [31] = DMACH_MAX,
 182         },
 183 };
 184
 185 #endif
 186
 187 static struct platform_device device_dmac1 = {
 188         .name           = "rk29-pl330",
 189         .id             = 1,
 190         .num_resources  = ARRAY_SIZE(resource_dmac1),
 191         .resource       = resource_dmac1,
 192         .dev            = {
 193                 .dma_mask = &dma_dmamask,
 194                 .coherent_dma_mask = DMA_BIT_MASK(32),
 195                 .platform_data = &dmac1_pdata,
 196         },
 197 };
 198
 199 static struct resource resource_dmac2[] = {
 200         [0] = {
 201                 .start  = RK30_DMAC2_PHYS,
 202                 .end    = RK30_DMAC2_PHYS + RK30_DMAC2_SIZE - 1,
 203                 .flags  = IORESOURCE_MEM,
 204         },
 205         [1] = {
 206                 .start  = IRQ_DMAC2_0,
 207                 .end    = IRQ_DMAC2_1,
 208                 .flags  = IORESOURCE_IRQ,
 209         },
 210 };
 211
 212 static struct rk29_pl330_platdata dmac2_pdata = {
 213         .peri = {
 214                 [0] = DMACH_HSADC,
 215                 [1] = DMACH_SDMMC,
 216                 [2] = DMACH_MAX,
 217                 [3] = DMACH_SDIO,
 218                 [4] = DMACH_EMMC,
 219                 [5] = DMACH_PID_FILTER,
 220                 [6] = DMACH_UART2_TX,
 221                 [7] = DMACH_UART2_RX,
 222                 [8] = DMACH_UART3_TX,
 223                 [9] = DMACH_UART3_RX,
 224                 [10] = DMACH_SPI0_TX,
 225                 [11] = DMACH_SPI0_RX,
 226                 [12] = DMACH_SPI1_TX,
 227                 [13] = DMACH_SPI1_RX,
 228                 [14] = DMACH_DMAC1_MEMTOMEM,
 229                 [15] = DMACH_MAX,
 230                 [16] = DMACH_MAX,
 231                 [17] = DMACH_MAX,
 232                 [18] = DMACH_MAX,
 233                 [19] = DMACH_MAX,
 234                 [20] = DMACH_MAX,
 235                 [21] = DMACH_MAX,
 236                 [22] = DMACH_MAX,
 237                 [23] = DMACH_MAX,
 238                 [24] = DMACH_MAX,
 239                 [25] = DMACH_MAX,
 240                 [26] = DMACH_MAX,
 241                 [27] = DMACH_MAX,
 242                 [28] = DMACH_MAX,
 243                 [29] = DMACH_MAX,
 244                 [30] = DMACH_MAX,
 245                 [31] = DMACH_MAX,
 246         },
 247 };
 248
 249 static struct platform_device device_dmac2 = {
 250         .name           = "rk29-pl330",
 251         .id             = 2,
 252         .num_resources  = ARRAY_SIZE(resource_dmac2),
 253         .resource       = resource_dmac2,
 254         .dev            = {
 255                 .dma_mask = &dma_dmamask,
 256                 .coherent_dma_mask = DMA_BIT_MASK(32),
 257                 .platform_data = &dmac2_pdata,
 258         },
 259 };
 260
 261 static struct platform_device *rk30_dmacs[] __initdata = {
 262         &device_dmac1,
 263         &device_dmac2,
 264 };
 265
 266 static void __init rk30_init_dma(void)
 267 {
 268         platform_add_devices(rk30_dmacs, ARRAY_SIZE(rk30_dmacs));
 269 }
 270
 271 #ifdef CONFIG_UART0_RK29
 272 static struct resource resources_uart0[] = {
 273         {
 274                 .start  = IRQ_UART0,
 275                 .end    = IRQ_UART0,
 276                 .flags  = IORESOURCE_IRQ,
 277         },
 278         {
 279                 .start  = RK30_UART0_PHYS,
 280                 .end    = RK30_UART0_PHYS + RK30_UART0_SIZE - 1,
 281                 .flags  = IORESOURCE_MEM,
 282         },
 283 };
 284
 285 static struct platform_device device_uart0 = {
 286         .name   = "rk_serial",
 287         .id     = 0,
 288         .num_resources  = ARRAY_SIZE(resources_uart0),
 289         .resource       = resources_uart0,
 290 };
 291 #endif
 292
 293 #ifdef CONFIG_UART1_RK29
 294 static struct resource resources_uart1[] = {
 295         {
 296                 .start  = IRQ_UART1,
 297                 .end    = IRQ_UART1,
 298                 .flags  = IORESOURCE_IRQ,
 299         },
 300         {
 301                 .start  = RK30_UART1_PHYS,
 302                 .end    = RK30_UART1_PHYS + RK30_UART1_SIZE - 1,
 303                 .flags  = IORESOURCE_MEM,
 304         },
 305 };
 306
 307 static struct platform_device device_uart1 = {
 308         .name   = "rk_serial",
 309         .id     = 1,
 310         .num_resources  = ARRAY_SIZE(resources_uart1),
 311         .resource       = resources_uart1,
 312 };
 313 #endif
 314
 315 #ifdef CONFIG_UART2_RK29
 316 static struct resource resources_uart2[] = {
 317         {
 318                 .start  = IRQ_UART2,
 319                 .end    = IRQ_UART2,
 320                 .flags  = IORESOURCE_IRQ,
 321         },
 322         {
 323                 .start  = RK30_UART2_PHYS,
 324                 .end    = RK30_UART2_PHYS + RK30_UART2_SIZE - 1,
 325                 .flags  = IORESOURCE_MEM,
 326         },
 327 };
 328
 329 static struct platform_device device_uart2 = {
 330         .name   = "rk_serial",
 331         .id     = 2,
 332         .num_resources  = ARRAY_SIZE(resources_uart2),
 333         .resource       = resources_uart2,
 334 };
 335 #endif
 336
 337 #ifdef CONFIG_UART3_RK29
 338 static struct resource resources_uart3[] = {
 339         {
 340                 .start  = IRQ_UART3,
 341                 .end    = IRQ_UART3,
 342                 .flags  = IORESOURCE_IRQ,
 343         },
 344         {
 345                 .start  = RK30_UART3_PHYS,
 346                 .end    = RK30_UART3_PHYS + RK30_UART3_SIZE - 1,
 347                 .flags  = IORESOURCE_MEM,
 348         },
 349 };
 350
 351 static struct platform_device device_uart3 = {
 352         .name   = "rk_serial",
 353         .id     = 3,
 354         .num_resources  = ARRAY_SIZE(resources_uart3),
 355         .resource       = resources_uart3,
 356 };
 357 #endif
 358
 359 static void __init rk30_init_uart(void)
 360 {
 361 #ifdef CONFIG_UART0_RK29
 362         platform_device_register(&device_uart0);
 363 #endif
 364 #ifdef CONFIG_UART1_RK29
 365         platform_device_register(&device_uart1);
 366 #endif
 367 #ifdef CONFIG_UART2_RK29
 368         platform_device_register(&device_uart2);
 369 #endif
 370 #ifdef CONFIG_UART3_RK29
 371         platform_device_register(&device_uart3);
 372 #endif
 373 }
 374
 375 #ifdef CONFIG_I2C0_CONTROLLER_RK29
 376 #define I2C0_ADAP_TYPE  I2C_RK29_ADAP
 377 #define I2C0_START      RK30_I2C0_PHYS
 378 #define I2C0_END        RK30_I2C0_PHYS + SZ_4K - 1
 379 #endif
 380 #ifdef CONFIG_I2C0_CONTROLLER_RK30
 381 #define I2C0_ADAP_TYPE   I2C_RK30_ADAP
 382 #define I2C0_START      RK30_I2C0_PHYS + SZ_4K
 383 #define I2C0_END        RK30_I2C0_PHYS + SZ_8K - 1
 384 #endif
 385
 386 #ifdef CONFIG_I2C1_CONTROLLER_RK29
 387 #define I2C1_ADAP_TYPE  I2C_RK29_ADAP
 388 #define I2C1_START      RK30_I2C1_PHYS
 389 #define I2C1_END        RK30_I2C1_PHYS + SZ_4K - 1
 390 #endif
 391 #ifdef CONFIG_I2C1_CONTROLLER_RK30
 392 #define I2C1_ADAP_TYPE   I2C_RK30_ADAP
 393 #define I2C1_START      RK30_I2C1_PHYS + SZ_4K
 394 #define I2C1_END        RK30_I2C1_PHYS + SZ_8K - 1
 395 #endif
 396
 397 #ifdef CONFIG_I2C2_CONTROLLER_RK29
 398 #define I2C2_ADAP_TYPE  I2C_RK29_ADAP
 399 #define I2C2_START      RK30_I2C2_PHYS
 400 #define I2C2_END        RK30_I2C2_PHYS + SZ_8K - 1
 401 #endif
 402 #ifdef CONFIG_I2C2_CONTROLLER_RK30
 403 #define I2C2_ADAP_TYPE   I2C_RK30_ADAP
 404 #define I2C2_START      RK30_I2C2_PHYS + SZ_8K
 405 #define I2C2_END        RK30_I2C2_PHYS + SZ_16K - 1
 406 #endif
 407
 408 #ifdef CONFIG_I2C3_CONTROLLER_RK29
 409 #define I2C3_ADAP_TYPE  I2C_RK29_ADAP
 410 #define I2C3_START      RK30_I2C3_PHYS
 411 #define I2C3_END        RK30_I2C3_PHYS + SZ_8K - 1
 412 #endif
 413 #ifdef CONFIG_I2C3_CONTROLLER_RK30
 414 #define I2C3_ADAP_TYPE   I2C_RK30_ADAP
 415 #define I2C3_START      RK30_I2C3_PHYS + SZ_8K
 416 #define I2C3_END        RK30_I2C3_PHYS + SZ_16K - 1
 417 #endif
 418
 419 #ifdef CONFIG_I2C4_CONTROLLER_RK29
 420 #define I2C4_ADAP_TYPE  I2C_RK29_ADAP
 421 #define I2C4_START      RK30_I2C4_PHYS
 422 #define I2C4_END        RK30_I2C4_PHYS + SZ_8K - 1
 423 #endif
 424 #ifdef CONFIG_I2C4_CONTROLLER_RK30
 425 #define I2C4_ADAP_TYPE   I2C_RK30_ADAP
 426 #define I2C4_START      RK30_I2C4_PHYS + SZ_8K
 427 #define I2C4_END        RK30_I2C4_PHYS + SZ_16K - 1
 428 #endif
 429
 430 #ifdef CONFIG_I2C0_RK30
 431 static struct rk30_i2c_platform_data default_i2c0_data = {
 432         .bus_num = 0,
 433 #if defined(CONFIG_ARCH_RK3066B)
 434         .is_div_from_arm = 0,
 435 #else
 436         .is_div_from_arm = 1,
 437 #endif
 438         .adap_type = I2C0_ADAP_TYPE,
 439         .sda_mode = I2C0_SDA,
 440         .scl_mode = I2C0_SCL,
 441 };
 442
 443 static struct resource resources_i2c0[] = {
 444         {
 445                 .start  = IRQ_I2C0,
 446                 .end    = IRQ_I2C0,
 447                 .flags  = IORESOURCE_IRQ,
 448         },
 449         {
 450                 .start  = I2C0_START,
 451         .end    = I2C0_END,
 452                 .flags  = IORESOURCE_MEM,
 453         },
 454 };
 455
 456 static struct platform_device device_i2c0 = {
 457         .name   = "rk30_i2c",
 458         .id     = 0,
 459         .num_resources  = ARRAY_SIZE(resources_i2c0),
 460         .resource       = resources_i2c0,
 461         .dev            = {
 462                 .platform_data = &default_i2c0_data,
 463         },
 464 };
 465 #endif
 466
 467 #ifdef CONFIG_I2C1_RK30
 468 static struct rk30_i2c_platform_data default_i2c1_data = {
 469         .bus_num = 1,
 470 #if defined(CONFIG_ARCH_RK3066B)
 471         .is_div_from_arm = 0,
 472 #else
 473         .is_div_from_arm = 1,
 474 #endif
 475         .adap_type = I2C1_ADAP_TYPE,
 476         .sda_mode = I2C1_SDA,
 477         .scl_mode = I2C1_SCL,
 478 };
 479
 480 static struct resource resources_i2c1[] = {
 481         {
 482                 .start  = IRQ_I2C1,
 483                 .end    = IRQ_I2C1,
 484                 .flags  = IORESOURCE_IRQ,
 485         },
 486         {
 487                 .start  = I2C1_START,
 488         .end    = I2C1_END,
 489                 .flags  = IORESOURCE_MEM,
 490         },
 491 };
 492
 493 static struct platform_device device_i2c1 = {
 494         .name   = "rk30_i2c",
 495         .id     = 1,
 496         .num_resources  = ARRAY_SIZE(resources_i2c1),
 497         .resource       = resources_i2c1,
 498         .dev            = {
 499                 .platform_data = &default_i2c1_data,
 500         },
 501 };
 502 #endif
 503
 504 #ifdef CONFIG_I2C2_RK30
 505 static struct rk30_i2c_platform_data default_i2c2_data = {
 506         .bus_num = 2,
 507         .is_div_from_arm = 0,
 508         .adap_type = I2C2_ADAP_TYPE,
 509         .sda_mode = I2C2_SDA,
 510         .scl_mode = I2C2_SCL,
 511 };
 512
 513 static struct resource resources_i2c2[] = {
 514         {
 515                 .start  = IRQ_I2C2,
 516                 .end    = IRQ_I2C2,
 517                 .flags  = IORESOURCE_IRQ,
 518         },
 519         {
 520                 .start  = I2C2_START,
 521         .end    = I2C2_END,
 522                 .flags  = IORESOURCE_MEM,
 523         },
 524 };
 525
 526 static struct platform_device device_i2c2 = {
 527         .name   = "rk30_i2c",
 528         .id     = 2,
 529         .num_resources  = ARRAY_SIZE(resources_i2c2),
 530         .resource       = resources_i2c2,
 531         .dev            = {
 532                 .platform_data = &default_i2c2_data,
 533         },
 534 };
 535 #endif
 536
 537 #ifdef CONFIG_I2C3_RK30
 538 static struct rk30_i2c_platform_data default_i2c3_data = {
 539         .bus_num = 3,
 540         .is_div_from_arm = 0,
 541         .adap_type = I2C3_ADAP_TYPE,
 542         .sda_mode = I2C3_SDA,
 543         .scl_mode = I2C3_SCL,
 544 };
 545
 546 static struct resource resources_i2c3[] = {
 547         {
 548                 .start  = IRQ_I2C3,
 549                 .end    = IRQ_I2C3,
 550                 .flags  = IORESOURCE_IRQ,
 551         },
 552         {
 553                 .start  = I2C3_START,
 554         .end    = I2C3_END,
 555                 .flags  = IORESOURCE_MEM,
 556         },
 557 };
 558
 559 static struct platform_device device_i2c3 = {
 560         .name   = "rk30_i2c",
 561         .id     = 3,
 562         .num_resources  = ARRAY_SIZE(resources_i2c3),
 563         .resource       = resources_i2c3,
 564         .dev            = {
 565                 .platform_data = &default_i2c3_data,
 566         },
 567 };
 568 #endif
 569
 570 #ifdef CONFIG_I2C4_RK30
 571 static struct rk30_i2c_platform_data default_i2c4_data = {
 572         .bus_num = 4,
 573         .is_div_from_arm = 0,
 574         .adap_type = I2C4_ADAP_TYPE,
 575         .sda_mode = I2C4_SDA,
 576         .scl_mode = I2C4_SCL,
 577 };
 578
 579 static struct resource resources_i2c4[] = {
 580         {
 581                 .start  = IRQ_I2C4,
 582                 .end    = IRQ_I2C4,
 583                 .flags  = IORESOURCE_IRQ,
 584         },
 585         {
 586                 .start  = I2C4_START,
 587         .end    = I2C4_END,
 588                 .flags  = IORESOURCE_MEM,
 589         },
 590 };
 591
 592 static struct platform_device device_i2c4 = {
 593         .name   = "rk30_i2c",
 594         .id     = 4,
 595         .num_resources  = ARRAY_SIZE(resources_i2c4),
 596         .resource       = resources_i2c4,
 597         .dev            = {
 598                 .platform_data = &default_i2c4_data,
 599         },
 600 };
 601 #endif
 602
 603 #ifdef CONFIG_I2C_GPIO_RK30
 604 static struct platform_device device_i2c_gpio = {
 605         .name   = "i2c-gpio",
 606         .id = 5,
 607         .dev            = {
 608                 .platform_data = &default_i2c_gpio_data,
 609         },
 610 };
 611 #endif
 612
 613 static void __init rk30_init_i2c(void)
 614 {
 615 #ifdef CONFIG_I2C0_RK30
 616         platform_device_register(&device_i2c0);
 617 #endif
 618 #ifdef CONFIG_I2C1_RK30
 619         platform_device_register(&device_i2c1);
 620 #endif
 621 #ifdef CONFIG_I2C2_RK30
 622         platform_device_register(&device_i2c2);
 623 #endif
 624 #ifdef CONFIG_I2C3_RK30
 625         platform_device_register(&device_i2c3);
 626 #endif
 627 #ifdef CONFIG_I2C4_RK30
 628         platform_device_register(&device_i2c4);
 629 #endif
 630 #ifdef CONFIG_I2C_GPIO_RK30
 631         platform_device_register(&device_i2c_gpio);
 632 #endif
 633 }
 634
 635 #if defined(CONFIG_SPIM0_RK29) || defined(CONFIG_SPIM1_RK29)
 636 /*****************************************************************************************
 637  * spi devices
 638  * author: cmc@rock-chips.com
 639  *****************************************************************************************/
 640 #define SPI_CHIPSELECT_NUM 2
 641
 642 static int spi_io_init(struct spi_cs_gpio *cs_gpios, int cs_num)
 643 {
 644         int i;
 645         if (cs_gpios) {
 646                 for (i = 0; i < cs_num; i++) {
 647                         rk30_mux_api_set(cs_gpios[i].cs_iomux_name, cs_gpios[i].cs_iomux_mode);
 648                 }
 649         }
 650         return 0;
 651 }
 652
 653 static int spi_io_deinit(struct spi_cs_gpio *cs_gpios, int cs_num)
 654 {
 655         return 0;
 656 }
 657
 658 static int spi_io_fix_leakage_bug(void)
 659 {
 660 #if 0
 661         gpio_direction_output(RK29_PIN2_PC1, GPIO_LOW);
 662 #endif
 663         return 0;
 664 }
 665
 666 static int spi_io_resume_leakage_bug(void)
 667 {
 668 #if 0
 669         gpio_direction_output(RK29_PIN2_PC1, GPIO_HIGH);
 670 #endif
 671         return 0;
 672 }
 673 #endif
 674
 675 /*
 676  * rk29xx spi master device
 677  */
 678 #ifdef CONFIG_SPIM0_RK29
 679 static struct spi_cs_gpio rk29xx_spi0_cs_gpios[SPI_CHIPSELECT_NUM] = {
 680 #if 0
 681 #if defined(CONFIG_ARCH_RK3066B)
 682         {
 683                 .name = "spi0 cs0",
 684                 .cs_gpio = RK30_PIN1_PA7,
 685                 .cs_iomux_name = GPIO1A7_UART1RTSN_SPI0CSN0_NAME,
 686                 .cs_iomux_mode = GPIO1A_SPI0CSN0,
 687         },
 688         {
 689                 .name = "spi0 cs1",
 690                 .cs_gpio = RK30_PIN1_PB7,
 691                 .cs_iomux_name = GPIO1B7_SPI0CSN1_NAME,//if no iomux,set it NULL
 692                 .cs_iomux_mode = GPIO1B_SPI0CSN1,
 693         }
 694
 695 #else
 696         {
 697                 .name = "spi0 cs0",
 698                 .cs_gpio = RK30_PIN1_PA4,
 699                 .cs_iomux_name = GPIO1A4_UART1SIN_SPI0CSN0_NAME,
 700                 .cs_iomux_mode = GPIO1A_SPI0_CSN0,
 701         },
 702         {
 703                 .name = "spi0 cs1",
 704                 .cs_gpio = RK30_PIN4_PB7,
 705                 .cs_iomux_name = GPIO4B7_SPI0CSN1_NAME,//if no iomux,set it NULL
 706                 .cs_iomux_mode = GPIO4B_SPI0_CSN1,
 707         }
 708 #endif
 709 #endif
 710 };
 711
 712 static struct rk29xx_spi_platform_data rk29xx_spi0_platdata = {
 713         .num_chipselect = SPI_CHIPSELECT_NUM,
 714         .chipselect_gpios = rk29xx_spi0_cs_gpios,
 715         .io_init = spi_io_init,
 716         .io_deinit = spi_io_deinit,
 717         .io_fix_leakage_bug = spi_io_fix_leakage_bug,
 718         .io_resume_leakage_bug = spi_io_resume_leakage_bug,
 719 };
 720
 721 static struct resource rk29_spi0_resources[] = {
 722         {
 723                 .start  = IRQ_SPI0,
 724                 .end    = IRQ_SPI0,
 725                 .flags  = IORESOURCE_IRQ,
 726         },
 727         {
 728                 .start  = RK30_SPI0_PHYS,
 729                 .end    = RK30_SPI0_PHYS + RK30_SPI0_SIZE - 1,
 730                 .flags  = IORESOURCE_MEM,
 731         },
 732         {
 733                 .start  = DMACH_SPI0_TX,
 734                 .end    = DMACH_SPI0_TX,
 735                 .flags  = IORESOURCE_DMA,
 736         },
 737         {
 738                 .start  = DMACH_SPI0_RX,
 739                 .end    = DMACH_SPI0_RX,
 740                 .flags  = IORESOURCE_DMA,
 741         },
 742 };
 743
 744 struct platform_device rk29xx_device_spi0m = {
 745         .name   = "rk29xx_spim",
 746         .id     = 0,
 747         .num_resources  = ARRAY_SIZE(rk29_spi0_resources),
 748         .resource       = rk29_spi0_resources,
 749         .dev                    = {
 750                 .dma_mask = &dma_dmamask,
 751                 .coherent_dma_mask = DMA_BIT_MASK(32),
 752                 .platform_data  = &rk29xx_spi0_platdata,
 753         },
 754 };
 755 #endif
 756
 757 #ifdef CONFIG_SPIM1_RK29
 758 static struct spi_cs_gpio rk29xx_spi1_cs_gpios[SPI_CHIPSELECT_NUM] = {
 759 #if 0
 760 #if defined(CONFIG_ARCH_RK3066B)
 761         {
 762                 .name = "spi1 cs0",
 763                 .cs_gpio = RK30_PIN0_PD7,
 764                 .cs_iomux_name = GPIO0D7_SPI1CSN0_NAME,
 765                 .cs_iomux_mode = GPIO0D_SPI1CSN0,
 766         },
 767         {
 768                 .name = "spi1 cs1",
 769                 .cs_gpio = RK30_PIN1_PB6,
 770                 .cs_iomux_name = GPIO1B6_SPDIFTX_SPI1CSN1_NAME,//if no iomux,set it NULL
 771                 .cs_iomux_mode = GPIO1B_SPI1CSN1,
 772         }
 773
 774 #else
 775         {
 776                 .name = "spi1 cs0",
 777                 .cs_gpio = RK30_PIN2_PC4,
 778                 .cs_iomux_name = GPIO2C4_LCDC1DATA20_SPI1CSN0_HSADCDATA1_NAME,
 779                 .cs_iomux_mode = GPIO2C_SPI1_CSN0,
 780         },
 781         {
 782                 .name = "spi1 cs1",
 783                 .cs_gpio = RK30_PIN2_PC7,
 784                 .cs_iomux_name = GPIO2C7_LCDC1DATA23_SPI1CSN1_HSADCDATA4_NAME,//if no iomux,set it NULL
 785                 .cs_iomux_mode = GPIO2C_SPI1_CSN1,
 786         }
 787 #endif
 788 #endif
 789 };
 790
 791 static struct rk29xx_spi_platform_data rk29xx_spi1_platdata = {
 792         .num_chipselect = SPI_CHIPSELECT_NUM,
 793         .chipselect_gpios = rk29xx_spi1_cs_gpios,
 794         .io_init = spi_io_init,
 795         .io_deinit = spi_io_deinit,
 796         .io_fix_leakage_bug = spi_io_fix_leakage_bug,
 797         .io_resume_leakage_bug = spi_io_resume_leakage_bug,
 798 };
 799
 800 static struct resource rk29_spi1_resources[] = {
 801         {
 802                 .start  = IRQ_SPI1,
 803                 .end    = IRQ_SPI1,
 804                 .flags  = IORESOURCE_IRQ,
 805         },
 806         {
 807                 .start  = RK30_SPI1_PHYS,
 808                 .end    = RK30_SPI1_PHYS + RK30_SPI1_SIZE - 1,
 809                 .flags  = IORESOURCE_MEM,
 810         },
 811         {
 812                 .start  = DMACH_SPI1_TX,
 813                 .end    = DMACH_SPI1_TX,
 814                 .flags  = IORESOURCE_DMA,
 815         },
 816         {
 817                 .start  = DMACH_SPI1_RX,
 818                 .end    = DMACH_SPI1_RX,
 819                 .flags  = IORESOURCE_DMA,
 820         },
 821 };
 822
 823 struct platform_device rk29xx_device_spi1m = {
 824         .name   = "rk29xx_spim",
 825         .id     = 1,
 826         .num_resources  = ARRAY_SIZE(rk29_spi1_resources),
 827         .resource       = rk29_spi1_resources,
 828         .dev                    = {
 829                 .dma_mask = &dma_dmamask,
 830                 .coherent_dma_mask = DMA_BIT_MASK(32),
 831                 .platform_data  = &rk29xx_spi1_platdata,
 832         },
 833 };
 834 #endif
 835
 836 static void __init rk30_init_spim(void)
 837 {
 838 #ifdef CONFIG_SPIM0_RK29
 839         platform_device_register(&rk29xx_device_spi0m);
 840 #endif
 841 #ifdef CONFIG_SPIM1_RK29
 842         platform_device_register(&rk29xx_device_spi1m);
 843 #endif
 844 }
 845
 846 #ifdef CONFIG_MTD_NAND_RK29XX
 847 static struct resource resources_nand[] = {
 848         {
 849                 .start  = RK30_NANDC_PHYS,
 850                 .end    = RK30_NANDC_PHYS + RK30_NANDC_SIZE - 1,
 851                 .flags  = IORESOURCE_MEM,
 852         }
 853 };
 854
 855 static struct platform_device device_nand = {
 856         .name           = "rk29xxnand",
 857         .id             = -1,
 858         .resource       = resources_nand,
 859         .num_resources  = ARRAY_SIZE(resources_nand),
 860 };
 861 #endif
 862
 863 #ifdef CONFIG_HDMI_RK30
 864 static struct resource resource_hdmi[] = {
 865         [0] = {
 866                 .start = RK30_HDMI_PHYS,
 867                 .end   = RK30_HDMI_PHYS + RK30_HDMI_SIZE - 1,
 868                 .flags = IORESOURCE_MEM,
 869         },
 870         [1] = {
 871                 .start = IRQ_HDMI,
 872                 .end   = IRQ_HDMI,
 873                 .flags = IORESOURCE_IRQ,
 874         },
 875 };
 876
 877 static struct platform_device device_hdmi = {
 878         .name                           = "rk30-hdmi",
 879         .id                                     = -1,
 880         .num_resources          = ARRAY_SIZE(resource_hdmi),
 881         .resource                       = resource_hdmi,
 882 };
 883 #endif
 884
 885 #ifdef CONFIG_RGA_RK30
 886 static struct resource resource_rga[] = {
 887         [0] = {
 888                 .start = RK30_RGA_PHYS,
 889                 .end   = RK30_RGA_PHYS + RK30_RGA_SIZE - 1,
 890                 .flags = IORESOURCE_MEM,
 891         },
 892         [1] = {
 893                 .start = IRQ_RGA,
 894                 .end   = IRQ_RGA,
 895                 .flags = IORESOURCE_IRQ,
 896         },
 897 };
 898
 899 static struct platform_device device_rga = {
 900         .name           = "rga",
 901         .id             = -1,
 902         .num_resources  = ARRAY_SIZE(resource_rga),
 903         .resource       = resource_rga,
 904 };
 905 #endif
 906
 907 static struct resource resource_ipp[] = {
 908         [0] = {
 909                 .start = RK30_IPP_PHYS,
 910                 .end   = RK30_IPP_PHYS + RK30_IPP_SIZE - 1,
 911                 .flags = IORESOURCE_MEM,
 912         },
 913         [1] = {
 914                 .start = IRQ_IPP,
 915                 .end   = IRQ_IPP,
 916                 .flags = IORESOURCE_IRQ,
 917         },
 918 };
 919
 920 static struct platform_device device_ipp = {
 921         .name           = "rk29-ipp",
 922         .id             = -1,
 923         .num_resources  = ARRAY_SIZE(resource_ipp),
 924         .resource       = resource_ipp,
 925 };
 926
 927 #ifdef CONFIG_SND_RK29_SOC_I2S
 928 #ifdef CONFIG_SND_RK29_SOC_I2S_8CH
 929 static struct resource resource_iis0_8ch[] = {
 930         [0] = {
 931                 .start  = RK30_I2S0_8CH_PHYS,
 932                 .end    = RK30_I2S0_8CH_PHYS + RK30_I2S0_8CH_SIZE - 1,
 933                 .flags  = IORESOURCE_MEM,
 934         },
 935         [1] = {
 936                 .start  = DMACH_I2S0_8CH_TX,
 937                 .end    = DMACH_I2S0_8CH_TX,
 938                 .flags  = IORESOURCE_DMA,
 939         },
 940         [2] = {
 941                 .start  = DMACH_I2S0_8CH_RX,
 942                 .end    = DMACH_I2S0_8CH_RX,
 943                 .flags  = IORESOURCE_DMA,
 944         },
 945         [3] = {
 946                 .start  = IRQ_I2S0_8CH,
 947                 .end    = IRQ_I2S0_8CH,
 948                 .flags  = IORESOURCE_IRQ,
 949         },
 950 };
 951
 952 static struct platform_device device_iis0_8ch = {
 953         .name           = "rk29_i2s",
 954         .id             = 0,
 955         .num_resources  = ARRAY_SIZE(resource_iis0_8ch),
 956         .resource       = resource_iis0_8ch,
 957 };
 958 #endif
 959 #ifdef CONFIG_SND_RK29_SOC_I2S_2CH
 960 static struct resource resource_iis1_2ch[] = {
 961         [0] = {
 962                 .start  = RK30_I2S1_2CH_PHYS,
 963                 .end    = RK30_I2S1_2CH_PHYS + RK30_I2S1_2CH_SIZE -1,
 964                 .flags  = IORESOURCE_MEM,
 965         },
 966         [1] = {
 967                 .start  = DMACH_I2S1_2CH_TX,
 968                 .end    = DMACH_I2S1_2CH_TX,
 969                 .flags  = IORESOURCE_DMA,
 970         },
 971         [2] = {
 972                 .start  = DMACH_I2S1_2CH_RX,
 973                 .end    = DMACH_I2S1_2CH_RX,
 974                 .flags  = IORESOURCE_DMA,
 975         },
 976         [3] = {
 977                 .start  = IRQ_I2S1_2CH,
 978                 .end    = IRQ_I2S1_2CH,
 979                 .flags  = IORESOURCE_IRQ,
 980         },
 981 };
 982
 983 static struct platform_device device_iis1_2ch = {
 984         .name           = "rk29_i2s",
 985         .id             = 1,
 986         .num_resources  = ARRAY_SIZE(resource_iis1_2ch),
 987         .resource       = resource_iis1_2ch,
 988 };
 989 #endif
 990 #ifdef CONFIG_SND_RK_SOC_I2S2_2CH
 991 static struct resource resource_iis2_2ch[] = {
 992         [0] = {
 993                 .start  = RK30_I2S2_2CH_PHYS,
 994                 .end    = RK30_I2S2_2CH_PHYS + RK30_I2S2_2CH_SIZE -1,
 995                 .flags  = IORESOURCE_MEM,
 996         },
 997         [1] = {
 998                 .start  = DMACH_I2S2_2CH_TX,
 999                 .end    = DMACH_I2S2_2CH_TX,
1000                 .flags  = IORESOURCE_DMA,
1001         },
1002         [2] = {
1003                 .start  = DMACH_I2S2_2CH_RX,
1004                 .end    = DMACH_I2S2_2CH_RX,
1005                 .flags  = IORESOURCE_DMA,
1006         },
1007         [3] = {
1008                 .start  = IRQ_I2S2_2CH,
1009                 .end    = IRQ_I2S2_2CH,
1010                 .flags  = IORESOURCE_IRQ,
1011         },
1012 };
1013
1014 static struct platform_device device_iis2_2ch = {
1015         .name           = "rk29_i2s",
1016         .id             = 2,
1017         .num_resources  = ARRAY_SIZE(resource_iis2_2ch),
1018         .resource       = resource_iis2_2ch,
1019 };
1020 #endif
1021 #endif
1022
1023 static struct platform_device device_pcm = {
1024         .name = "rockchip-audio",
1025         .id = -1,
1026 };
1027
1028 static void __init rk30_init_i2s(void)
1029 {
1030 #ifdef CONFIG_SND_RK29_SOC_I2S_8CH
1031         platform_device_register(&device_iis0_8ch);
1032 #endif
1033 #ifdef CONFIG_SND_RK29_SOC_I2S_2CH
1034         platform_device_register(&device_iis1_2ch);
1035 #endif
1036 #ifdef CONFIG_SND_RK_SOC_I2S2_2CH
1037         platform_device_register(&device_iis2_2ch);
1038 #endif
1039         platform_device_register(&device_pcm);
1040 }
1041
1042
1043
1044 #ifdef CONFIG_KEYS_RK29
1045 extern struct rk29_keys_platform_data rk29_keys_pdata;
1046 static struct platform_device device_keys = {
1047         .name           = "rk29-keypad",
1048         .id             = -1,
1049         .dev            = {
1050                 .platform_data  = &rk29_keys_pdata,
1051         },
1052 };
1053 #endif
1054
1055 #ifdef CONFIG_SDMMC0_RK29
1056 static struct resource resources_sdmmc0[] = {
1057         {
1058                 .start  = IRQ_SDMMC,
1059                 .end    = IRQ_SDMMC,
1060                 .flags  = IORESOURCE_IRQ,
1061         },
1062         {
1063                 .start  = RK30_SDMMC0_PHYS,
1064                 .end    = RK30_SDMMC0_PHYS + RK30_SDMMC0_SIZE -1,
1065                 .flags  = IORESOURCE_MEM,
1066         }
1067 };
1068
1069 static struct platform_device device_sdmmc0 = {
1070         .name           = "rk29_sdmmc",
1071         .id             = 0,
1072         .num_resources  = ARRAY_SIZE(resources_sdmmc0),
1073         .resource       = resources_sdmmc0,
1074         .dev            = {
1075                 .platform_data = &default_sdmmc0_data,
1076         },
1077 };
1078 #endif
1079
1080 #ifdef CONFIG_SDMMC1_RK29
1081 static struct resource resources_sdmmc1[] = {
1082         {
1083                 .start  = IRQ_SDIO,
1084                 .end    = IRQ_SDIO,
1085                 .flags  = IORESOURCE_IRQ,
1086         },
1087         {
1088                 .start  = RK30_SDIO_PHYS,
1089                 .end    = RK30_SDIO_PHYS + RK30_SDIO_SIZE - 1,
1090                 .flags  = IORESOURCE_MEM,
1091         }
1092 };
1093
1094 static struct platform_device device_sdmmc1 = {
1095         .name           = "rk29_sdmmc",
1096         .id             = 1,
1097         .num_resources  = ARRAY_SIZE(resources_sdmmc1),
1098         .resource       = resources_sdmmc1,
1099         .dev            = {
1100                 .platform_data = &default_sdmmc1_data,
1101         },
1102 };
1103 #endif
1104
1105 static void __init rk30_init_sdmmc(void)
1106 {
1107 #ifdef CONFIG_SDMMC0_RK29
1108         platform_device_register(&device_sdmmc0);
1109 #endif
1110 #ifdef CONFIG_SDMMC1_RK29
1111         platform_device_register(&device_sdmmc1);
1112 #endif
1113 }
1114
1115 #ifdef CONFIG_SND_RK_SOC_SPDIF
1116 static struct resource resources_spdif[] = {
1117     [0] = {
1118                 .name   = "spdif_base",
1119         .start  = RK30_SPDIF_PHYS,
1120         .end    = RK30_SPDIF_PHYS + RK30_SPDIF_SIZE - 1,
1121         .flags  = IORESOURCE_MEM,
1122     },
1123     [1] = {
1124                 .name   = "spdif_irq",
1125         .start  = IRQ_SPDIF,
1126         .end    = IRQ_SPDIF,
1127         .flags  = IORESOURCE_IRQ,
1128     },
1129     [2] = {
1130                 .name   = "spdif_dma",
1131         .start  = DMACH_SPDIF_TX,
1132         .end    = DMACH_SPDIF_TX,
1133         .flags  = IORESOURCE_DMA,
1134     },
1135 };
1136 struct platform_device rk29_device_spdif = {
1137     .name             = "rk-spdif",
1138     .id               = 0,
1139     .num_resources    = ARRAY_SIZE(resources_spdif),
1140     .resource         = resources_spdif,
1141 };
1142 #endif
1143
1144 #ifdef CONFIG_RK29_VMAC
1145 static u64 eth_dmamask = DMA_BIT_MASK(32);
1146 static struct resource resources_vmac[] = {
1147         [0] = {
1148                 .start  = RK30_MAC_PHYS,
1149                 .end    = RK30_MAC_PHYS + RK30_MAC_SIZE - 1,
1150                 .flags  = IORESOURCE_MEM,
1151         },
1152         [1] = {
1153                 .start  = IRQ_MAC,
1154                 .end    = IRQ_MAC,
1155                 .flags  = IORESOURCE_IRQ,
1156         }
1157 };
1158
1159 static struct platform_device device_vmac = {
1160         .name           = "rk29 vmac",
1161         .id             = 0,
1162         .dev = {
1163                 .dma_mask               = &eth_dmamask,
1164                 .coherent_dma_mask      = DMA_BIT_MASK(32),
1165                 .platform_data          = &board_vmac_data,
1166         },
1167         .num_resources  = ARRAY_SIZE(resources_vmac),
1168         .resource       = resources_vmac,
1169 };
1170 #endif
1171
1172 #ifdef CONFIG_RK29_WATCHDOG
1173 static struct resource resources_wdt[] = {
1174         {
1175                 .start  = IRQ_WDT,
1176                 .end    = IRQ_WDT,
1177                 .flags  = IORESOURCE_IRQ,
1178         },
1179         {
1180                 .start  = RK30_WDT_PHYS,
1181                 .end    = RK30_WDT_PHYS + RK30_WDT_SIZE - 1,
1182                 .flags  = IORESOURCE_MEM,
1183         },
1184 };
1185
1186 static struct platform_device device_wdt = {
1187         .name   = "rk29-wdt",
1188         .id     = 0,
1189         .num_resources  = ARRAY_SIZE(resources_wdt),
1190         .resource       = resources_wdt,
1191 };
1192 #endif
1193
1194 static struct resource resource_arm_pmu[] = {
1195         {
1196                 .start  = IRQ_ARM_PMU,
1197                 .end    = IRQ_ARM_PMU,
1198                 .flags  = IORESOURCE_IRQ,
1199         },
1200         {
1201                 .start  = IRQ_ARM_PMU + 1,
1202                 .end    = IRQ_ARM_PMU + 1,
1203                 .flags  = IORESOURCE_IRQ,
1204         },
1205 #if defined(CONFIG_ARCH_RK3188)
1206         {
1207                 .start  = IRQ_ARM_PMU + 2,
1208                 .end    = IRQ_ARM_PMU + 2,
1209                 .flags  = IORESOURCE_IRQ,
1210         },
1211         {
1212                 .start  = IRQ_ARM_PMU + 3,
1213                 .end    = IRQ_ARM_PMU + 3,
1214                 .flags  = IORESOURCE_IRQ,
1215         },
1216 #endif
1217 };
1218
1219 struct platform_device device_arm_pmu = {
1220         .name           = "arm-pmu",
1221         .id             = ARM_PMU_DEVICE_CPU,
1222         .num_resources  = ARRAY_SIZE(resource_arm_pmu),
1223         .resource       = resource_arm_pmu,
1224 };
1225
1226 static int __init rk30_init_devices(void)
1227 {
1228         rk30_init_dma();
1229         rk30_init_uart();
1230         rk30_init_i2c();
1231         rk30_init_spim();
1232 #ifdef CONFIG_RGA_RK30
1233         platform_device_register(&device_rga);
1234 #endif
1235         platform_device_register(&device_ipp);
1236
1237 #ifdef CONFIG_HDMI_RK30
1238         platform_device_register(&device_hdmi);
1239 #endif
1240 #ifdef CONFIG_ADC_RK30
1241         platform_device_register(&device_adc);
1242 #endif
1243 #ifdef CONFIG_KEYS_RK29
1244         platform_device_register(&device_keys);
1245 #endif
1246         rk30_init_tsadc();
1247         rk30_init_sdmmc();
1248 #if defined(CONFIG_FIQ_DEBUGGER) && defined(DEBUG_UART_PHYS)
1249         rk_serial_debug_init(DEBUG_UART_BASE, IRQ_DEBUG_UART, IRQ_UART_SIGNAL, -1);
1250 #endif
1251         rk30_init_i2s();
1252
1253 #ifdef CONFIG_SND_RK_SOC_SPDIF
1254     platform_device_register(&rk29_device_spdif);
1255 #endif
1256 #ifdef CONFIG_RK29_VMAC
1257         platform_device_register(&device_vmac);
1258 #endif
1259 #ifdef CONFIG_RK29_WATCHDOG
1260         platform_device_register(&device_wdt);
1261 #endif
1262         platform_device_register(&device_arm_pmu);
1263 #ifdef CONFIG_MTD_NAND_RK29XX
1264         platform_device_register(&device_nand);
1265 #endif
1266
1267         return 0;
1268 }
1269 arch_initcall(rk30_init_devices);