arch/arm/mach-ux500/board-mop500.c

   1
   2 /*
   3  * Copyright (C) 2008-2009 ST-Ericsson
   4  *
   5  * Author: Srinidhi KASAGAR <srinidhi.kasagar@stericsson.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2, as
   9  * published by the Free Software Foundation.
  10  *
  11  */
  12 #include <linux/kernel.h>
  13 #include <linux/init.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/io.h>
  17 #include <linux/i2c.h>
  18 #include <linux/platform_data/i2c-nomadik.h>
  19 #include <linux/gpio.h>
  20 #include <linux/amba/bus.h>
  21 #include <linux/amba/pl022.h>
  22 #include <linux/amba/serial.h>
  23 #include <linux/spi/spi.h>
  24 #include <linux/mfd/abx500/ab8500.h>
  25 #include <linux/regulator/ab8500.h>
  26 #include <linux/regulator/fixed.h>
  27 #include <linux/mfd/tc3589x.h>
  28 #include <linux/mfd/tps6105x.h>
  29 #include <linux/mfd/abx500/ab8500-gpio.h>
  30 #include <linux/mfd/abx500/ab8500-codec.h>
  31 #include <linux/leds-lp5521.h>
  32 #include <linux/input.h>
  33 #include <linux/smsc911x.h>
  34 #include <linux/gpio_keys.h>
  35 #include <linux/delay.h>
  36 #include <linux/of.h>
  37 #include <linux/of_platform.h>
  38 #include <linux/leds.h>
  39 #include <linux/pinctrl/consumer.h>
  40
  41 #include <asm/mach-types.h>
  42 #include <asm/mach/arch.h>
  43 #include <asm/hardware/gic.h>
  44
  45 #include <plat/ste_dma40.h>
  46 #include <plat/gpio-nomadik.h>
  47
  48 #include <mach/hardware.h>
  49 #include <mach/setup.h>
  50 #include <mach/devices.h>
  51 #include <mach/irqs.h>
  52 #include <mach/crypto-ux500.h>
  53
  54 #include "ste-dma40-db8500.h"
  55 #include "devices-db8500.h"
  56 #include "board-mop500.h"
  57 #include "board-mop500-regulators.h"
  58
  59 static struct gpio_led snowball_led_array[] = {
  60         {
  61                 .name = "user_led",
  62                 .default_trigger = "heartbeat",
  63                 .gpio = 142,
  64         },
  65 };
  66
  67 static struct gpio_led_platform_data snowball_led_data = {
  68         .leds = snowball_led_array,
  69         .num_leds = ARRAY_SIZE(snowball_led_array),
  70 };
  71
  72 static struct platform_device snowball_led_dev = {
  73         .name = "leds-gpio",
  74         .dev = {
  75                 .platform_data = &snowball_led_data,
  76         },
  77 };
  78
  79 static struct fixed_voltage_config snowball_gpio_en_3v3_data = {
  80        .supply_name            = "EN-3V3",
  81        .gpio                   = SNOWBALL_EN_3V3_ETH_GPIO,
  82        .microvolts             = 3300000,
  83        .enable_high            = 1,
  84        .init_data              = &gpio_en_3v3_regulator,
  85        .startup_delay          = 5000, /* 1200us */
  86 };
  87
  88 static struct platform_device snowball_gpio_en_3v3_regulator_dev = {
  89        .name   = "reg-fixed-voltage",
  90        .id     = 1,
  91        .dev    = {
  92                .platform_data  = &snowball_gpio_en_3v3_data,
  93        },
  94 };
  95
  96 static struct ab8500_gpio_platform_data ab8500_gpio_pdata = {
  97         .gpio_base              = MOP500_AB8500_PIN_GPIO(1),
  98         .irq_base               = MOP500_AB8500_VIR_GPIO_IRQ_BASE,
  99         /* config_reg is the initial configuration of ab8500 pins.
 100          * The pins can be configured as GPIO or alt functions based
 101          * on value present in GpioSel1 to GpioSel6 and AlternatFunction
 102          * register. This is the array of 7 configuration settings.
 103          * One has to compile time decide these settings. Below is the
 104          * explanation of these setting
 105          * GpioSel1 = 0x00 => Pins GPIO1 to GPIO8 are not used as GPIO
 106          * GpioSel2 = 0x1E => Pins GPIO10 to GPIO13 are configured as GPIO
 107          * GpioSel3 = 0x80 => Pin GPIO24 is configured as GPIO
 108          * GpioSel4 = 0x01 => Pin GPIo25 is configured as GPIO
 109          * GpioSel5 = 0x7A => Pins GPIO34, GPIO36 to GPIO39 are conf as GPIO
 110          * GpioSel6 = 0x00 => Pins GPIO41 & GPIo42 are not configured as GPIO
 111          * AlternaFunction = 0x00 => If Pins GPIO10 to 13 are not configured
 112          * as GPIO then this register selectes the alternate fucntions
 113          */
 114         .config_reg             = {0x00, 0x1E, 0x80, 0x01,
 115                                         0x7A, 0x00, 0x00},
 116 };
 117
 118 /* ab8500-codec */
 119 static struct ab8500_codec_platform_data ab8500_codec_pdata = {
 120         .amics =  {
 121                 .mic1_type = AMIC_TYPE_DIFFERENTIAL,
 122                 .mic2_type = AMIC_TYPE_DIFFERENTIAL,
 123                 .mic1a_micbias = AMIC_MICBIAS_VAMIC1,
 124                 .mic1b_micbias = AMIC_MICBIAS_VAMIC1,
 125                 .mic2_micbias = AMIC_MICBIAS_VAMIC2
 126         },
 127         .ear_cmv = EAR_CMV_0_95V
 128 };
 129
 130 static struct gpio_keys_button snowball_key_array[] = {
 131         {
 132                 .gpio           = 32,
 133                 .type           = EV_KEY,
 134                 .code           = KEY_1,
 135                 .desc           = "userpb",
 136                 .active_low     = 1,
 137                 .debounce_interval = 50,
 138                 .wakeup         = 1,
 139         },
 140         {
 141                 .gpio           = 151,
 142                 .type           = EV_KEY,
 143                 .code           = KEY_2,
 144                 .desc           = "extkb1",
 145                 .active_low     = 1,
 146                 .debounce_interval = 50,
 147                 .wakeup         = 1,
 148         },
 149         {
 150                 .gpio           = 152,
 151                 .type           = EV_KEY,
 152                 .code           = KEY_3,
 153                 .desc           = "extkb2",
 154                 .active_low     = 1,
 155                 .debounce_interval = 50,
 156                 .wakeup         = 1,
 157         },
 158         {
 159                 .gpio           = 161,
 160                 .type           = EV_KEY,
 161                 .code           = KEY_4,
 162                 .desc           = "extkb3",
 163                 .active_low     = 1,
 164                 .debounce_interval = 50,
 165                 .wakeup         = 1,
 166         },
 167         {
 168                 .gpio           = 162,
 169                 .type           = EV_KEY,
 170                 .code           = KEY_5,
 171                 .desc           = "extkb4",
 172                 .active_low     = 1,
 173                 .debounce_interval = 50,
 174                 .wakeup         = 1,
 175         },
 176 };
 177
 178 static struct gpio_keys_platform_data snowball_key_data = {
 179         .buttons        = snowball_key_array,
 180         .nbuttons       = ARRAY_SIZE(snowball_key_array),
 181 };
 182
 183 static struct platform_device snowball_key_dev = {
 184         .name           = "gpio-keys",
 185         .id             = -1,
 186         .dev            = {
 187                 .platform_data  = &snowball_key_data,
 188         }
 189 };
 190
 191 static struct smsc911x_platform_config snowball_sbnet_cfg = {
 192         .irq_polarity = SMSC911X_IRQ_POLARITY_ACTIVE_HIGH,
 193         .irq_type = SMSC911X_IRQ_TYPE_PUSH_PULL,
 194         .flags = SMSC911X_USE_16BIT | SMSC911X_FORCE_INTERNAL_PHY,
 195         .shift = 1,
 196 };
 197
 198 static struct resource sbnet_res[] = {
 199         {
 200                 .name = "smsc911x-memory",
 201                 .start = (0x5000 << 16),
 202                 .end  =  (0x5000 << 16) + 0xffff,
 203                 .flags = IORESOURCE_MEM,
 204         },
 205         {
 206                 .start = NOMADIK_GPIO_TO_IRQ(140),
 207                 .end = NOMADIK_GPIO_TO_IRQ(140),
 208                 .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE,
 209         },
 210 };
 211
 212 static struct platform_device snowball_sbnet_dev = {
 213         .name           = "smsc911x",
 214         .num_resources  = ARRAY_SIZE(sbnet_res),
 215         .resource       = sbnet_res,
 216         .dev            = {
 217                 .platform_data = &snowball_sbnet_cfg,
 218         },
 219 };
 220
 221 static struct ab8500_platform_data ab8500_platdata = {
 222         .irq_base       = MOP500_AB8500_IRQ_BASE,
 223         .regulator_reg_init = ab8500_regulator_reg_init,
 224         .num_regulator_reg_init = ARRAY_SIZE(ab8500_regulator_reg_init),
 225         .regulator      = ab8500_regulators,
 226         .num_regulator  = ARRAY_SIZE(ab8500_regulators),
 227         .gpio           = &ab8500_gpio_pdata,
 228         .codec          = &ab8500_codec_pdata,
 229 };
 230
 231 /*
 232  * TPS61052
 233  */
 234
 235 static struct tps6105x_platform_data mop500_tps61052_data = {
 236         .mode = TPS6105X_MODE_VOLTAGE,
 237         .regulator_data = &tps61052_regulator,
 238 };
 239
 240 /*
 241  * TC35892
 242  */
 243
 244 static void mop500_tc35892_init(struct tc3589x *tc3589x, unsigned int base)
 245 {
 246         struct device *parent = NULL;
 247 #if 0
 248         /* FIXME: Is the sdi actually part of tc3589x? */
 249         parent = tc3589x->dev;
 250 #endif
 251         mop500_sdi_tc35892_init(parent);
 252 }
 253
 254 static struct tc3589x_gpio_platform_data mop500_tc35892_gpio_data = {
 255         .gpio_base      = MOP500_EGPIO(0),
 256         .setup          = mop500_tc35892_init,
 257 };
 258
 259 static struct tc3589x_platform_data mop500_tc35892_data = {
 260         .block          = TC3589x_BLOCK_GPIO,
 261         .gpio           = &mop500_tc35892_gpio_data,
 262         .irq_base       = MOP500_EGPIO_IRQ_BASE,
 263 };
 264
 265 static struct lp5521_led_config lp5521_pri_led[] = {
 266        [0] = {
 267                .chan_nr = 0,
 268                .led_current = 0x2f,
 269                .max_current = 0x5f,
 270        },
 271        [1] = {
 272                .chan_nr = 1,
 273                .led_current = 0x2f,
 274                .max_current = 0x5f,
 275        },
 276        [2] = {
 277                .chan_nr = 2,
 278                .led_current = 0x2f,
 279                .max_current = 0x5f,
 280        },
 281 };
 282
 283 static struct lp5521_platform_data __initdata lp5521_pri_data = {
 284        .label = "lp5521_pri",
 285        .led_config     = &lp5521_pri_led[0],
 286        .num_channels   = 3,
 287        .clock_mode     = LP5521_CLOCK_EXT,
 288 };
 289
 290 static struct lp5521_led_config lp5521_sec_led[] = {
 291        [0] = {
 292                .chan_nr = 0,
 293                .led_current = 0x2f,
 294                .max_current = 0x5f,
 295        },
 296        [1] = {
 297                .chan_nr = 1,
 298                .led_current = 0x2f,
 299                .max_current = 0x5f,
 300        },
 301        [2] = {
 302                .chan_nr = 2,
 303                .led_current = 0x2f,
 304                .max_current = 0x5f,
 305        },
 306 };
 307
 308 static struct lp5521_platform_data __initdata lp5521_sec_data = {
 309        .label = "lp5521_sec",
 310        .led_config     = &lp5521_sec_led[0],
 311        .num_channels   = 3,
 312        .clock_mode     = LP5521_CLOCK_EXT,
 313 };
 314
 315 static struct i2c_board_info __initdata mop500_i2c0_devices[] = {
 316         {
 317                 I2C_BOARD_INFO("tc3589x", 0x42),
 318                 .irq            = NOMADIK_GPIO_TO_IRQ(217),
 319                 .platform_data  = &mop500_tc35892_data,
 320         },
 321         /* I2C0 devices only available prior to HREFv60 */
 322         {
 323                 I2C_BOARD_INFO("tps61052", 0x33),
 324                 .platform_data  = &mop500_tps61052_data,
 325         },
 326 };
 327
 328 #define NUM_PRE_V60_I2C0_DEVICES 1
 329
 330 static struct i2c_board_info __initdata mop500_i2c2_devices[] = {
 331         {
 332                 /* lp5521 LED driver, 1st device */
 333                 I2C_BOARD_INFO("lp5521", 0x33),
 334                 .platform_data = &lp5521_pri_data,
 335         },
 336         {
 337                 /* lp5521 LED driver, 2st device */
 338                 I2C_BOARD_INFO("lp5521", 0x34),
 339                 .platform_data = &lp5521_sec_data,
 340         },
 341         {
 342                 /* Light sensor Rohm BH1780GLI */
 343                 I2C_BOARD_INFO("bh1780", 0x29),
 344         },
 345 };
 346
 347 static void __init mop500_i2c_init(struct device *parent)
 348 {
 349         db8500_add_i2c0(parent, NULL);
 350         db8500_add_i2c1(parent, NULL);
 351         db8500_add_i2c2(parent, NULL);
 352         db8500_add_i2c3(parent, NULL);
 353 }
 354
 355 static struct gpio_keys_button mop500_gpio_keys[] = {
 356         {
 357                 .desc                   = "SFH7741 Proximity Sensor",
 358                 .type                   = EV_SW,
 359                 .code                   = SW_FRONT_PROXIMITY,
 360                 .active_low             = 0,
 361                 .can_disable            = 1,
 362         }
 363 };
 364
 365 static struct regulator *prox_regulator;
 366 static int mop500_prox_activate(struct device *dev);
 367 static void mop500_prox_deactivate(struct device *dev);
 368
 369 static struct gpio_keys_platform_data mop500_gpio_keys_data = {
 370         .buttons        = mop500_gpio_keys,
 371         .nbuttons       = ARRAY_SIZE(mop500_gpio_keys),
 372         .enable         = mop500_prox_activate,
 373         .disable        = mop500_prox_deactivate,
 374 };
 375
 376 static struct platform_device mop500_gpio_keys_device = {
 377         .name   = "gpio-keys",
 378         .id     = 0,
 379         .dev    = {
 380                 .platform_data  = &mop500_gpio_keys_data,
 381         },
 382 };
 383
 384 static int mop500_prox_activate(struct device *dev)
 385 {
 386         prox_regulator = regulator_get(&mop500_gpio_keys_device.dev,
 387                                                 "vcc");
 388         if (IS_ERR(prox_regulator)) {
 389                 dev_err(&mop500_gpio_keys_device.dev,
 390                         "no regulator\n");
 391                 return PTR_ERR(prox_regulator);
 392         }
 393         regulator_enable(prox_regulator);
 394         return 0;
 395 }
 396
 397 static void mop500_prox_deactivate(struct device *dev)
 398 {
 399         regulator_disable(prox_regulator);
 400         regulator_put(prox_regulator);
 401 }
 402
 403 static struct cryp_platform_data u8500_cryp1_platform_data = {
 404                 .mem_to_engine = {
 405                                 .dir = STEDMA40_MEM_TO_PERIPH,
 406                                 .src_dev_type = STEDMA40_DEV_SRC_MEMORY,
 407                                 .dst_dev_type = DB8500_DMA_DEV48_CAC1_TX,
 408                                 .src_info.data_width = STEDMA40_WORD_WIDTH,
 409                                 .dst_info.data_width = STEDMA40_WORD_WIDTH,
 410                                 .mode = STEDMA40_MODE_LOGICAL,
 411                                 .src_info.psize = STEDMA40_PSIZE_LOG_4,
 412                                 .dst_info.psize = STEDMA40_PSIZE_LOG_4,
 413                 },
 414                 .engine_to_mem = {
 415                                 .dir = STEDMA40_PERIPH_TO_MEM,
 416                                 .src_dev_type = DB8500_DMA_DEV48_CAC1_RX,
 417                                 .dst_dev_type = STEDMA40_DEV_DST_MEMORY,
 418                                 .src_info.data_width = STEDMA40_WORD_WIDTH,
 419                                 .dst_info.data_width = STEDMA40_WORD_WIDTH,
 420                                 .mode = STEDMA40_MODE_LOGICAL,
 421                                 .src_info.psize = STEDMA40_PSIZE_LOG_4,
 422                                 .dst_info.psize = STEDMA40_PSIZE_LOG_4,
 423                 }
 424 };
 425
 426 static struct stedma40_chan_cfg u8500_hash_dma_cfg_tx = {
 427                 .dir = STEDMA40_MEM_TO_PERIPH,
 428                 .src_dev_type = STEDMA40_DEV_SRC_MEMORY,
 429                 .dst_dev_type = DB8500_DMA_DEV50_HAC1_TX,
 430                 .src_info.data_width = STEDMA40_WORD_WIDTH,
 431                 .dst_info.data_width = STEDMA40_WORD_WIDTH,
 432                 .mode = STEDMA40_MODE_LOGICAL,
 433                 .src_info.psize = STEDMA40_PSIZE_LOG_16,
 434                 .dst_info.psize = STEDMA40_PSIZE_LOG_16,
 435 };
 436
 437 static struct hash_platform_data u8500_hash1_platform_data = {
 438                 .mem_to_engine = &u8500_hash_dma_cfg_tx,
 439                 .dma_filter = stedma40_filter,
 440 };
 441
 442 /* add any platform devices here - TODO */
 443 static struct platform_device *mop500_platform_devs[] __initdata = {
 444         &mop500_gpio_keys_device,
 445 };
 446
 447 #ifdef CONFIG_STE_DMA40
 448 static struct stedma40_chan_cfg ssp0_dma_cfg_rx = {
 449         .mode = STEDMA40_MODE_LOGICAL,
 450         .dir = STEDMA40_PERIPH_TO_MEM,
 451         .src_dev_type =  DB8500_DMA_DEV8_SSP0_RX,
 452         .dst_dev_type = STEDMA40_DEV_DST_MEMORY,
 453         .src_info.data_width = STEDMA40_BYTE_WIDTH,
 454         .dst_info.data_width = STEDMA40_BYTE_WIDTH,
 455 };
 456
 457 static struct stedma40_chan_cfg ssp0_dma_cfg_tx = {
 458         .mode = STEDMA40_MODE_LOGICAL,
 459         .dir = STEDMA40_MEM_TO_PERIPH,
 460         .src_dev_type = STEDMA40_DEV_SRC_MEMORY,
 461         .dst_dev_type = DB8500_DMA_DEV8_SSP0_TX,
 462         .src_info.data_width = STEDMA40_BYTE_WIDTH,
 463         .dst_info.data_width = STEDMA40_BYTE_WIDTH,
 464 };
 465 #endif
 466
 467 static struct pl022_ssp_controller ssp0_plat = {
 468         .bus_id = 0,
 469 #ifdef CONFIG_STE_DMA40
 470         .enable_dma = 1,
 471         .dma_filter = stedma40_filter,
 472         .dma_rx_param = &ssp0_dma_cfg_rx,
 473         .dma_tx_param = &ssp0_dma_cfg_tx,
 474 #else
 475         .enable_dma = 0,
 476 #endif
 477         /* on this platform, gpio 31,142,144,214 &
 478          * 224 are connected as chip selects
 479          */
 480         .num_chipselect = 5,
 481 };
 482
 483 static void __init mop500_spi_init(struct device *parent)
 484 {
 485         db8500_add_ssp0(parent, &ssp0_plat);
 486 }
 487
 488 #ifdef CONFIG_STE_DMA40
 489 static struct stedma40_chan_cfg uart0_dma_cfg_rx = {
 490         .mode = STEDMA40_MODE_LOGICAL,
 491         .dir = STEDMA40_PERIPH_TO_MEM,
 492         .src_dev_type =  DB8500_DMA_DEV13_UART0_RX,
 493         .dst_dev_type = STEDMA40_DEV_DST_MEMORY,
 494         .src_info.data_width = STEDMA40_BYTE_WIDTH,
 495         .dst_info.data_width = STEDMA40_BYTE_WIDTH,
 496 };
 497
 498 static struct stedma40_chan_cfg uart0_dma_cfg_tx = {
 499         .mode = STEDMA40_MODE_LOGICAL,
 500         .dir = STEDMA40_MEM_TO_PERIPH,
 501         .src_dev_type = STEDMA40_DEV_SRC_MEMORY,
 502         .dst_dev_type = DB8500_DMA_DEV13_UART0_TX,
 503         .src_info.data_width = STEDMA40_BYTE_WIDTH,
 504         .dst_info.data_width = STEDMA40_BYTE_WIDTH,
 505 };
 506
 507 static struct stedma40_chan_cfg uart1_dma_cfg_rx = {
 508         .mode = STEDMA40_MODE_LOGICAL,
 509         .dir = STEDMA40_PERIPH_TO_MEM,
 510         .src_dev_type =  DB8500_DMA_DEV12_UART1_RX,
 511         .dst_dev_type = STEDMA40_DEV_DST_MEMORY,
 512         .src_info.data_width = STEDMA40_BYTE_WIDTH,
 513         .dst_info.data_width = STEDMA40_BYTE_WIDTH,
 514 };
 515
 516 static struct stedma40_chan_cfg uart1_dma_cfg_tx = {
 517         .mode = STEDMA40_MODE_LOGICAL,
 518         .dir = STEDMA40_MEM_TO_PERIPH,
 519         .src_dev_type = STEDMA40_DEV_SRC_MEMORY,
 520         .dst_dev_type = DB8500_DMA_DEV12_UART1_TX,
 521         .src_info.data_width = STEDMA40_BYTE_WIDTH,
 522         .dst_info.data_width = STEDMA40_BYTE_WIDTH,
 523 };
 524
 525 static struct stedma40_chan_cfg uart2_dma_cfg_rx = {
 526         .mode = STEDMA40_MODE_LOGICAL,
 527         .dir = STEDMA40_PERIPH_TO_MEM,
 528         .src_dev_type =  DB8500_DMA_DEV11_UART2_RX,
 529         .dst_dev_type = STEDMA40_DEV_DST_MEMORY,
 530         .src_info.data_width = STEDMA40_BYTE_WIDTH,
 531         .dst_info.data_width = STEDMA40_BYTE_WIDTH,
 532 };
 533
 534 static struct stedma40_chan_cfg uart2_dma_cfg_tx = {
 535         .mode = STEDMA40_MODE_LOGICAL,
 536         .dir = STEDMA40_MEM_TO_PERIPH,
 537         .src_dev_type = STEDMA40_DEV_SRC_MEMORY,
 538         .dst_dev_type = DB8500_DMA_DEV11_UART2_TX,
 539         .src_info.data_width = STEDMA40_BYTE_WIDTH,
 540         .dst_info.data_width = STEDMA40_BYTE_WIDTH,
 541 };
 542 #endif
 543
 544 static struct amba_pl011_data uart0_plat = {
 545 #ifdef CONFIG_STE_DMA40
 546         .dma_filter = stedma40_filter,
 547         .dma_rx_param = &uart0_dma_cfg_rx,
 548         .dma_tx_param = &uart0_dma_cfg_tx,
 549 #endif
 550 };
 551
 552 static struct amba_pl011_data uart1_plat = {
 553 #ifdef CONFIG_STE_DMA40
 554         .dma_filter = stedma40_filter,
 555         .dma_rx_param = &uart1_dma_cfg_rx,
 556         .dma_tx_param = &uart1_dma_cfg_tx,
 557 #endif
 558 };
 559
 560 static struct amba_pl011_data uart2_plat = {
 561 #ifdef CONFIG_STE_DMA40
 562         .dma_filter = stedma40_filter,
 563         .dma_rx_param = &uart2_dma_cfg_rx,
 564         .dma_tx_param = &uart2_dma_cfg_tx,
 565 #endif
 566 };
 567
 568 static void __init mop500_uart_init(struct device *parent)
 569 {
 570         db8500_add_uart0(parent, &uart0_plat);
 571         db8500_add_uart1(parent, &uart1_plat);
 572         db8500_add_uart2(parent, &uart2_plat);
 573 }
 574
 575 static void __init u8500_cryp1_hash1_init(struct device *parent)
 576 {
 577         db8500_add_cryp1(parent, &u8500_cryp1_platform_data);
 578         db8500_add_hash1(parent, &u8500_hash1_platform_data);
 579 }
 580
 581 static struct platform_device *snowball_platform_devs[] __initdata = {
 582         &snowball_led_dev,
 583         &snowball_key_dev,
 584         &snowball_sbnet_dev,
 585         &snowball_gpio_en_3v3_regulator_dev,
 586 };
 587
 588 static void __init mop500_init_machine(void)
 589 {
 590         struct device *parent = NULL;
 591         int i2c0_devs;
 592         int i;
 593
 594         mop500_gpio_keys[0].gpio = GPIO_PROX_SENSOR;
 595
 596         mop500_pinmaps_init();
 597         parent = u8500_init_devices(&ab8500_platdata);
 598
 599         for (i = 0; i < ARRAY_SIZE(mop500_platform_devs); i++)
 600                 mop500_platform_devs[i]->dev.parent = parent;
 601
 602         platform_add_devices(mop500_platform_devs,
 603                         ARRAY_SIZE(mop500_platform_devs));
 604
 605         mop500_i2c_init(parent);
 606         mop500_sdi_init(parent);
 607         mop500_spi_init(parent);
 608         mop500_audio_init(parent);
 609         mop500_uart_init(parent);
 610
 611         u8500_cryp1_hash1_init(parent);
 612
 613         i2c0_devs = ARRAY_SIZE(mop500_i2c0_devices);
 614
 615         i2c_register_board_info(0, mop500_i2c0_devices, i2c0_devs);
 616         i2c_register_board_info(2, mop500_i2c2_devices,
 617                                 ARRAY_SIZE(mop500_i2c2_devices));
 618
 619         /* This board has full regulator constraints */
 620         regulator_has_full_constraints();
 621
 622         mop500_uib_init();
 623 }
 624
 625 static void __init snowball_init_machine(void)
 626 {
 627         struct device *parent = NULL;
 628         int i;
 629
 630         snowball_pinmaps_init();
 631         parent = u8500_init_devices(&ab8500_platdata);
 632
 633         for (i = 0; i < ARRAY_SIZE(snowball_platform_devs); i++)
 634                 snowball_platform_devs[i]->dev.parent = parent;
 635
 636         platform_add_devices(snowball_platform_devs,
 637                         ARRAY_SIZE(snowball_platform_devs));
 638
 639         mop500_i2c_init(parent);
 640         snowball_sdi_init(parent);
 641         mop500_spi_init(parent);
 642         mop500_audio_init(parent);
 643         mop500_uart_init(parent);
 644
 645         /* This board has full regulator constraints */
 646         regulator_has_full_constraints();
 647 }
 648
 649 static void __init hrefv60_init_machine(void)
 650 {
 651         struct device *parent = NULL;
 652         int i2c0_devs;
 653         int i;
 654
 655         /*
 656          * The HREFv60 board removed a GPIO expander and routed
 657          * all these GPIO pins to the internal GPIO controller
 658          * instead.
 659          */
 660         mop500_gpio_keys[0].gpio = HREFV60_PROX_SENSE_GPIO;
 661
 662         hrefv60_pinmaps_init();
 663         parent = u8500_init_devices(&ab8500_platdata);
 664
 665         for (i = 0; i < ARRAY_SIZE(mop500_platform_devs); i++)
 666                 mop500_platform_devs[i]->dev.parent = parent;
 667
 668         platform_add_devices(mop500_platform_devs,
 669                         ARRAY_SIZE(mop500_platform_devs));
 670
 671         mop500_i2c_init(parent);
 672         hrefv60_sdi_init(parent);
 673         mop500_spi_init(parent);
 674         mop500_audio_init(parent);
 675         mop500_uart_init(parent);
 676
 677         i2c0_devs = ARRAY_SIZE(mop500_i2c0_devices);
 678
 679         i2c0_devs -= NUM_PRE_V60_I2C0_DEVICES;
 680
 681         i2c_register_board_info(0, mop500_i2c0_devices, i2c0_devs);
 682         i2c_register_board_info(2, mop500_i2c2_devices,
 683                                 ARRAY_SIZE(mop500_i2c2_devices));
 684
 685         /* This board has full regulator constraints */
 686         regulator_has_full_constraints();
 687
 688         mop500_uib_init();
 689 }
 690
 691 MACHINE_START(U8500, "ST-Ericsson MOP500 platform")
 692         /* Maintainer: Srinidhi Kasagar <srinidhi.kasagar@stericsson.com> */
 693         .atag_offset    = 0x100,
 694         .map_io         = u8500_map_io,
 695         .init_irq       = ux500_init_irq,
 696         /* we re-use nomadik timer here */
 697         .timer          = &ux500_timer,
 698         .handle_irq     = gic_handle_irq,
 699         .init_machine   = mop500_init_machine,
 700         .init_late      = ux500_init_late,
 701 MACHINE_END
 702
 703 MACHINE_START(HREFV60, "ST-Ericsson U8500 Platform HREFv60+")
 704         .atag_offset    = 0x100,
 705         .map_io         = u8500_map_io,
 706         .init_irq       = ux500_init_irq,
 707         .timer          = &ux500_timer,
 708         .handle_irq     = gic_handle_irq,
 709         .init_machine   = hrefv60_init_machine,
 710         .init_late      = ux500_init_late,
 711 MACHINE_END
 712
 713 MACHINE_START(SNOWBALL, "Calao Systems Snowball platform")
 714         .atag_offset    = 0x100,
 715         .map_io         = u8500_map_io,
 716         .init_irq       = ux500_init_irq,
 717         /* we re-use nomadik timer here */
 718         .timer          = &ux500_timer,
 719         .handle_irq     = gic_handle_irq,
 720         .init_machine   = snowball_init_machine,
 721         .init_late      = ux500_init_late,
 722 MACHINE_END
 723
 724 #ifdef CONFIG_MACH_UX500_DT
 725
 726 struct of_dev_auxdata u8500_auxdata_lookup[] __initdata = {
 727         /* Requires call-back bindings. */
 728         OF_DEV_AUXDATA("arm,cortex-a9-pmu", 0, "arm-pmu", &db8500_pmu_platdata),
 729         /* Requires DMA and call-back bindings. */
 730         OF_DEV_AUXDATA("arm,pl011", 0x80120000, "uart0", &uart0_plat),
 731         OF_DEV_AUXDATA("arm,pl011", 0x80121000, "uart1", &uart1_plat),
 732         OF_DEV_AUXDATA("arm,pl011", 0x80007000, "uart2", &uart2_plat),
 733         /* Requires DMA bindings. */
 734         OF_DEV_AUXDATA("arm,pl022", 0x80002000, "ssp0",  &ssp0_plat),
 735         OF_DEV_AUXDATA("arm,pl18x", 0x80126000, "sdi0",  &mop500_sdi0_data),
 736         OF_DEV_AUXDATA("arm,pl18x", 0x80118000, "sdi1",  &mop500_sdi1_data),
 737         OF_DEV_AUXDATA("arm,pl18x", 0x80005000, "sdi2",  &mop500_sdi2_data),
 738         OF_DEV_AUXDATA("arm,pl18x", 0x80114000, "sdi4",  &mop500_sdi4_data),
 739         /* Requires clock name bindings. */
 740         OF_DEV_AUXDATA("st,nomadik-gpio", 0x8012e000, "gpio.0", NULL),
 741         OF_DEV_AUXDATA("st,nomadik-gpio", 0x8012e080, "gpio.1", NULL),
 742         OF_DEV_AUXDATA("st,nomadik-gpio", 0x8000e000, "gpio.2", NULL),
 743         OF_DEV_AUXDATA("st,nomadik-gpio", 0x8000e080, "gpio.3", NULL),
 744         OF_DEV_AUXDATA("st,nomadik-gpio", 0x8000e100, "gpio.4", NULL),
 745         OF_DEV_AUXDATA("st,nomadik-gpio", 0x8000e180, "gpio.5", NULL),
 746         OF_DEV_AUXDATA("st,nomadik-gpio", 0x8011e000, "gpio.6", NULL),
 747         OF_DEV_AUXDATA("st,nomadik-gpio", 0x8011e080, "gpio.7", NULL),
 748         OF_DEV_AUXDATA("st,nomadik-gpio", 0xa03fe000, "gpio.8", NULL),
 749         OF_DEV_AUXDATA("st,nomadik-i2c", 0x80004000, "nmk-i2c.0", NULL),
 750         OF_DEV_AUXDATA("st,nomadik-i2c", 0x80122000, "nmk-i2c.1", NULL),
 751         OF_DEV_AUXDATA("st,nomadik-i2c", 0x80128000, "nmk-i2c.2", NULL),
 752         OF_DEV_AUXDATA("st,nomadik-i2c", 0x80110000, "nmk-i2c.3", NULL),
 753         OF_DEV_AUXDATA("st,nomadik-i2c", 0x8012a000, "nmk-i2c.4", NULL),
 754         /* Requires device name bindings. */
 755         OF_DEV_AUXDATA("stericsson,nmk_pinctrl", 0, "pinctrl-db8500", NULL),
 756         /* Requires clock name and DMA bindings. */
 757         OF_DEV_AUXDATA("stericsson,ux500-msp-i2s", 0x80123000,
 758                 "ux500-msp-i2s.0", &msp0_platform_data),
 759         OF_DEV_AUXDATA("stericsson,ux500-msp-i2s", 0x80124000,
 760                 "ux500-msp-i2s.1", &msp1_platform_data),
 761         OF_DEV_AUXDATA("stericsson,ux500-msp-i2s", 0x80117000,
 762                 "ux500-msp-i2s.2", &msp2_platform_data),
 763         OF_DEV_AUXDATA("stericsson,ux500-msp-i2s", 0x80125000,
 764                 "ux500-msp-i2s.3", &msp3_platform_data),
 765         {},
 766 };
 767
 768 static const struct of_device_id u8500_local_bus_nodes[] = {
 769         /* only create devices below soc node */
 770         { .compatible = "stericsson,db8500", },
 771         { .compatible = "stericsson,db8500-prcmu", },
 772         { .compatible = "simple-bus"},
 773         { },
 774 };
 775
 776 static void __init u8500_init_machine(void)
 777 {
 778         struct device *parent = NULL;
 779         int i2c0_devs;
 780         int i;
 781
 782         /* Pinmaps must be in place before devices register */
 783         if (of_machine_is_compatible("st-ericsson,mop500"))
 784                 mop500_pinmaps_init();
 785         else if (of_machine_is_compatible("calaosystems,snowball-a9500"))
 786                 snowball_pinmaps_init();
 787         else if (of_machine_is_compatible("st-ericsson,hrefv60+"))
 788                 hrefv60_pinmaps_init();
 789
 790         parent = u8500_of_init_devices();
 791
 792         for (i = 0; i < ARRAY_SIZE(mop500_platform_devs); i++)
 793                 mop500_platform_devs[i]->dev.parent = parent;
 794
 795         /* automatically probe child nodes of db8500 device */
 796         of_platform_populate(NULL, u8500_local_bus_nodes, u8500_auxdata_lookup, parent);
 797
 798         if (of_machine_is_compatible("st-ericsson,mop500")) {
 799                 mop500_gpio_keys[0].gpio = GPIO_PROX_SENSOR;
 800
 801                 platform_add_devices(mop500_platform_devs,
 802                                 ARRAY_SIZE(mop500_platform_devs));
 803
 804                 mop500_sdi_init(parent);
 805                 mop500_audio_init(parent);
 806                 i2c0_devs = ARRAY_SIZE(mop500_i2c0_devices);
 807                 i2c_register_board_info(0, mop500_i2c0_devices, i2c0_devs);
 808                 i2c_register_board_info(2, mop500_i2c2_devices,
 809                                         ARRAY_SIZE(mop500_i2c2_devices));
 810
 811                 mop500_uib_init();
 812
 813         } else if (of_machine_is_compatible("calaosystems,snowball-a9500")) {
 814                 mop500_of_audio_init(parent);
 815         } else if (of_machine_is_compatible("st-ericsson,hrefv60+")) {
 816                 /*
 817                  * The HREFv60 board removed a GPIO expander and routed
 818                  * all these GPIO pins to the internal GPIO controller
 819                  * instead.
 820                  */
 821                 mop500_gpio_keys[0].gpio = HREFV60_PROX_SENSE_GPIO;
 822                 platform_add_devices(mop500_platform_devs,
 823                                 ARRAY_SIZE(mop500_platform_devs));
 824
 825                 mop500_uib_init();
 826         }
 827
 828         /* This board has full regulator constraints */
 829         regulator_has_full_constraints();
 830 }
 831
 832 static const char * u8500_dt_board_compat[] = {
 833         "calaosystems,snowball-a9500",
 834         "st-ericsson,hrefv60+",
 835         "st-ericsson,u8500",
 836         "st-ericsson,mop500",
 837         NULL,
 838 };
 839
 840
 841 DT_MACHINE_START(U8500_DT, "ST-Ericsson U8500 platform (Device Tree Support)")
 842         .map_io         = u8500_map_io,
 843         .init_irq       = ux500_init_irq,
 844         /* we re-use nomadik timer here */
 845         .timer          = &ux500_timer,
 846         .handle_irq     = gic_handle_irq,
 847         .init_machine   = u8500_init_machine,
 848         .init_late      = ux500_init_late,
 849         .dt_compat      = u8500_dt_board_compat,
 850 MACHINE_END
 851 #endif