diff options
Diffstat (limited to 'arch/arm/mach-omap2/board-omap3h1.c')
| -rw-r--r-- | arch/arm/mach-omap2/board-omap3h1.c | 1267 |
1 files changed, 1267 insertions, 0 deletions
diff --git a/arch/arm/mach-omap2/board-omap3h1.c b/arch/arm/mach-omap2/board-omap3h1.c new file mode 100644 index 00000000000..61c01c90a8f --- /dev/null +++ b/arch/arm/mach-omap2/board-omap3h1.c @@ -0,0 +1,1267 @@ +/* + * Copyright (C) 2014 Olio Devices, Inc. + * Authors: Evan Wilson <evan@oliodevices.com> + * Mattis Fjallstrom <mattis@oliodevices.com> + * + * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/ + * + * Modified from the original mach-omap/omap2/board-generic.c did by Paul + * to support the OMAP2+ device tree boards with an unique board file. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ +#include <linux/kernel.h> +#include <linux/init.h> +#include <linux/platform_device.h> +#include <linux/delay.h> +#include <linux/err.h> +#include <linux/clk.h> +#include <linux/io.h> +#include <linux/opp.h> +#include <linux/cpu.h> +#include <linux/mpu.h> +#include <linux/spi/spi.h> +#include <linux/mtd/mtd.h> +#include <linux/mtd/partitions.h> +#include <linux/mtd/nand.h> + +#include <linux/usb/musb.h> +#include <linux/usb/phy.h> +#include <linux/usb/nop-usb-xceiv.h> + +#include <linux/i2c/atmel_mxt_ts.h> +#include <linux/gpio.h> + +#include <linux/regulator/machine.h> +#include <linux/regulator/fixed.h> +#include <linux/mfd/tps65910.h> + +#include <linux/wakelock.h> /* used in interrupt, waking up. */ +#include <linux/debugfs.h> + +#include <linux/led-lm3530.h> + +#include <asm/mach-types.h> +#include <asm/mach/arch.h> +#include <asm/mach/map.h> +#include <asm/mach/flash.h> + +#include <video/omapdss.h> +#include <video/omap-panel-data.h> +#include <linux/platform_data/mtd-nand-omap2.h> +#include <linux/platform_data/serial-omap.h> +#include <linux/interrupt.h> + +#include <linux/of_irq.h> +#include <linux/of_platform.h> + + +#include "common.h" +#include "omap_device.h" +#include "gpmc.h" +#include "soc.h" +#include "mux.h" +#include "pm.h" +#include "board-flash.h" +#include "common-board-devices.h" +#include "board-omap3h1.h" + +#include "sdram-micron-mt29c4g48.h" + +#define NAND_CS 0 + +#define MPUIRQ_GPIO 31 +#define ATMEL_MXT_GPIO 105 +#define TPS_SYS_NIRQ 0 +#define USB_IRQ 124 +#define USB_ON_ETK_D7 21 + +#define DEFAULT_RXDMA_POLLRATE 1 /* RX DMA polling rate (us) */ +#define DEFAULT_RXDMA_BUFSIZE 4096 /* RX DMA buffer size */ +#define DEFAULT_RXDMA_TIMEOUT (3 * HZ)/* RX DMA timeout (jiffies) */ + +#if defined(CONFIG_MACH_OMAP3_H1_DVT1) || defined(CONFIG_MACH_OMAP3_H1_DVT2) +#define LCD_RESET_GPIO 94 +#else +#define LCD_RESET_GPIO 122 +#endif + +static struct accelerometer_wake { + int awake; + struct wake_lock lock; + char lock_name[100]; + int user_pid; +} acc_wake; + +static struct mtd_partition omap3h1_nand_partitions[] = { + /* All the partition sizes are listed in terms of NAND block size */ + { + .name = "X-Loader", + .offset = 0, + .size = 4 * NAND_BLOCK_SIZE, + .mask_flags = MTD_WRITEABLE, /* force read-only */ + }, + { + .name = "U-Boot", + .offset = MTDPART_OFS_APPEND, /* Offset = 0x80000 */ + .size = 15 * NAND_BLOCK_SIZE, + .mask_flags = MTD_WRITEABLE, /* force read-only */ + }, + { + .name = "U-Boot Env", + .offset = MTDPART_OFS_APPEND, /* Offset = 0x260000 */ + .size = 1 * NAND_BLOCK_SIZE, + }, + { + .name = "kernel", + .offset = MTDPART_OFS_APPEND, /* Offset = 0x280000 */ + .size = 40 * NAND_BLOCK_SIZE, + }, + { + .name = "initramfs", + .offset = MTDPART_OFS_APPEND, /* Offset = 0xC80000 */ + .size = 80 * NAND_BLOCK_SIZE, + }, + { + .name = "ramdisk", + .offset = MTDPART_OFS_APPEND, /* Offset = 0x1180000 */ + .size = 40 * NAND_BLOCK_SIZE, + }, + { + .name = "system", + .offset = MTDPART_OFS_APPEND, /* Offset = 0x1680000 */ + .size = 2000 * NAND_BLOCK_SIZE, + }, + { + .name = "userdata", + .offset = MTDPART_OFS_APPEND, /* Offset = 0x11180000 */ + .size = MTDPART_SIZ_FULL, + }, +}; + +static struct omap_dss_device omap3h1_lcd_device = { + .type = OMAP_DISPLAY_TYPE_DPI, + .name = "olio_h1_panel", + .driver_name = "ili9342_panel", + .phy.dpi.data_lines = 18, + .reset_gpio = LCD_RESET_GPIO, +}; + +static struct omap_dss_device *omap3h1_dss_devices[] = { + &omap3h1_lcd_device, +}; + +static struct omap_dss_board_info omap3h1_dss_data = { + .num_devices = 1, + .devices = omap3h1_dss_devices, + .default_device = &omap3h1_lcd_device, +}; + +static struct spi_board_info omap3h1_spi_board_info[] __initdata = { + { + .modalias = "ili9342-spi", + .bus_num = 1, + .chip_select = 1, + .max_speed_hz = 375000, + .platform_data = &omap3h1_lcd_device, + .mode = SPI_MODE_0, + } +}; + +static int __init omap3h1_spi_init(void) { + spi_register_board_info(omap3h1_spi_board_info, + ARRAY_SIZE(omap3h1_spi_board_info)); + return 0; +} + + +/* + * int_config is interrupt config, INT_ENABLE register. To enable _all_ + * interrupts, set to 0x59. I think. --mfj + * + * Level shifter seems to set power rail between two options - 1 means VDD. + * (0 means VLogic, which I'm not sure what it is). + */ + +static struct mpu_platform_data mpu_data = { + .int_config = 0x00, + .level_shifter = 1, + .orientation = { 0, -1, 0, + -1, 0, 0, + 0, 0, 1 }, +}; + +static struct lm3530_platform_data omap3h1_backlight_platform_data = { + .mode = LM3530_BL_MODE_MANUAL, + //.als_input_mode = LM3530_INPUT_ALS1, + .max_current = LM3530_FS_CURR_29mA, + //.pwm_pol_hi = true, + //.als_avrg_time = LM3530_ALS_AVRG_TIME_512ms, + .brt_ramp_law = 0, + .brt_ramp_fall = LM3530_RAMP_TIME_1s, /* LM3530_RAMP_TIME_1s, */ + .brt_ramp_rise = LM3530_RAMP_TIME_1s, /* LM3530_RAMP_TIME_1s, */ + //.als1_resistor_sel = LM3530_ALS_IMPD_13_53kOhm, + //.als2_resistor_sel = LM3530_ALS_IMPD_Z, + //.als_vmin = 730, /* mV */ + //.als_vmax = 10a20, /* mV */ + .brt_val = 0x64, /* initial brightness */ +}; + + + +static struct mxt_platform_data mxt_data = { + .irqflags = IRQF_TRIGGER_FALLING, +}; + +/* +static struct platform_device bcm20702_bluetooth_device = { + .name = "bcm20702_bluetooth", + .id = -1, + }; +*/ + +static struct platform_device omap3h1_dmic_codec = { + .name = "dmic-codec", + .id = -1, +}; + +/* --------------------------------------------------------------------------- */ +/* USB settings + */ + + + +static struct omap_musb_board_data musb_board_data = { + .interface_type = MUSB_INTERFACE_ULPI, + .mode = MUSB_OTG, + .power = 100, +}; + +static struct nop_usb_xceiv_platform_data nop_plat_data = { + .type = USB_PHY_TYPE_USB2, + .clk_rate = 60000000, /* 60 MHz */ + .needs_vcc = 1, + .needs_reset = 0, +}; + +static struct platform_device nop_phy_device = { + .name = "nop_usb_xceiv", + .id = -1, + .dev = { + .platform_data = &nop_plat_data, + }, +}; + + +/* static struct usbhs_omap_platform_data usbhs_bdata __initdata = { */ +/* .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY, */ +/* }; */ + + +/* --------------------------------------------------------------------------- */ +/* REGULATOR - Fixed first + */ + +static struct regulator_init_data omap3h1_vbat_data = { + .constraints.always_on = true, + .constraints.valid_modes_mask = REGULATOR_MODE_NORMAL, + .constraints.valid_ops_mask = REGULATOR_CHANGE_MODE | REGULATOR_CHANGE_STATUS, +}; + +static struct fixed_voltage_config omap3h1_vbat_pdata = { + .supply_name = "VBAT", + .microvolts = 3800000, + .init_data = &omap3h1_vbat_data, + .gpio = -EINVAL, +}; + +static struct platform_device omap3h1_vbat = { + .name = "reg-fixed-voltage", + .id = -1, + .dev = { + .platform_data = &omap3h1_vbat_pdata, + }, +}; + + +/* --------------------------------------------------------------------------- */ + +static struct regulator_init_data tps65910_dummy = { + .supply_regulator = "VBAT", + .constraints.always_on = false, + .constraints.valid_ops_mask = REGULATOR_CHANGE_STATUS, +}; + +/* --------------------------------------------------------------------------- */ +/* This one is required for the display to work. + */ + +static struct regulator_consumer_supply tps65910_touch3_supply[] = { + REGULATOR_SUPPLY("avdd", "2-004a"), + REGULATOR_SUPPLY("vdd", "spi1.1"), +}; + +static struct regulator_init_data tps65910_touch3 = { + .supply_regulator = "VBAT", + .constraints = { + .min_uV = 3300000, + .max_uV = 3300000, + .valid_modes_mask = REGULATOR_MODE_NORMAL | REGULATOR_MODE_STANDBY, + .valid_ops_mask = REGULATOR_CHANGE_STATUS | REGULATOR_CHANGE_MODE, + .always_on = false, + .apply_uV = true, + + .state_mem = { + .uV = 0, + .mode = REGULATOR_MODE_STANDBY, + .disabled = 1, + }, + .state_disk = { + .uV = 0, + .mode = REGULATOR_MODE_STANDBY, + .disabled = 1, + }, + .state_standby = { + .uV = 0, + .mode = REGULATOR_MODE_STANDBY, + .disabled = 1, + }, + }, + + .num_consumer_supplies = ARRAY_SIZE(tps65910_touch3_supply), + .consumer_supplies = tps65910_touch3_supply, +}; + +/* --------------------------------------------------------------------------- */ +/* This regulator is for the vibrator. We currently lack a way of enabling / + * disabling this since we lack a driver for the vibrator (we're just accessing + * it's registers through the i2c bus). + * + * Hence, it's always on. + */ + +static struct regulator_consumer_supply tps65910_vibrator_supply[] = { + REGULATOR_SUPPLY("vaux2", "drv2605"), +}; + +static struct regulator_init_data tps65910_vibrator = { + .supply_regulator = "VBAT", + .constraints = { + .min_uV = 3300000, + .max_uV = 3300000, + .valid_modes_mask = REGULATOR_MODE_NORMAL | REGULATOR_MODE_STANDBY, + .valid_ops_mask = REGULATOR_CHANGE_MODE, + .always_on = false, + .apply_uV = true, + + .state_mem = { + .disabled = 1, + }, + .state_disk = { + .disabled = 1, + }, + .state_standby = { + .disabled = 1, + }, + }, + .num_consumer_supplies = ARRAY_SIZE(tps65910_vibrator_supply), + .consumer_supplies = tps65910_vibrator_supply, +}; + + + +/* --------------------------------------------------------------------------- */ +/* Seems like this one has to be on. It doesn't have any "official" consumers + * ... but it's definitely needed. Bluetooth relies on it. + */ + +/* +static struct regulator_consumer_supply tps65910_bluetooth_3v3[] = { + REGULATOR_SUPPLY("clk32ksys", 0), +}; +*/ + +static struct regulator_init_data tps65910_3v3 = { + .supply_regulator = "VBAT", + .constraints = { + .min_uV = 3300000, + .max_uV = 3300000, + .valid_modes_mask = REGULATOR_MODE_NORMAL | REGULATOR_MODE_STANDBY, + .valid_ops_mask = REGULATOR_CHANGE_MODE | + REGULATOR_CHANGE_STATUS, + .always_on = false, + .apply_uV = true, + + .state_mem = { + .disabled = 1, + }, + .state_disk = { + .disabled = 1, + }, + .state_standby = { + .disabled = 1, + }, + }, + +}; + + +/* --------------------------------------------------------------------------- */ +/* This is the OMAP display subsystem. Part of the OMAP processor OCP stuff. + * USB also depends on this, so if you want to transfer files it has to be + * always on. + * NAND flash and UART3 (which we don't use) requires it + * as well. And the i2c bus, and lots of other stuff. + * + * Setting always_on to "false" resulted in almost no power savings, at + * least in the current setting. + */ + +static struct regulator_consumer_supply tps65910_1v8_supply[] = { + REGULATOR_SUPPLY("vdds_dsi", "omapdss"), +}; + +static struct regulator_init_data tps65910_1v8 = { + .supply_regulator = "VBAT", + .constraints = { + .min_uV = 1800000, + .max_uV = 1800000, + .valid_modes_mask = REGULATOR_MODE_NORMAL | REGULATOR_MODE_IDLE | REGULATOR_MODE_STANDBY, + .valid_ops_mask = REGULATOR_CHANGE_MODE, + .always_on = false, + .apply_uV = true, + }, + .num_consumer_supplies = ARRAY_SIZE(tps65910_1v8_supply), + .consumer_supplies = tps65910_1v8_supply, +}; + +/* --------------------------------------------------------------------------- */ +/* There's no driver explicitly using this one, but it goes to VDDA_DPLL_PER + * on the OMAP chip. So it's used internally by the DPLL devices in PER, I think. + */ + +static struct regulator_consumer_supply tps65910_vpll_supply[] = { + +}; + +static struct regulator_init_data tps65910_vpll = { + .supply_regulator = "VBAT", + .constraints = { + .min_uV = 1800000, + .max_uV = 1800000, + .valid_modes_mask = REGULATOR_MODE_NORMAL | REGULATOR_MODE_STANDBY, + .valid_ops_mask = REGULATOR_CHANGE_MODE | REGULATOR_CHANGE_STATUS, + .always_on = true, + .apply_uV = true, + }, + .num_consumer_supplies = ARRAY_SIZE(tps65910_vpll_supply), + .consumer_supplies = tps65910_vpll_supply, +}; + + +/* --------------------------------------------------------------------------- */ +/* Touch power supply part 2. + */ + +static struct regulator_consumer_supply tps65910_touch_supply[] = { + REGULATOR_SUPPLY("vdd", "2-004a" ), +}; + +static struct regulator_init_data tps65910_touch = { + .supply_regulator = "VBAT", + .constraints = { + .min_uV = 1800000, + .max_uV = 1800000, + .valid_modes_mask = REGULATOR_MODE_NORMAL | REGULATOR_MODE_STANDBY, + .valid_ops_mask = REGULATOR_CHANGE_MODE | REGULATOR_CHANGE_STATUS, + .always_on = false, + .apply_uV = true, + + .state_mem = { + .uV = 1, + .mode = REGULATOR_MODE_STANDBY, + .disabled = 1, + }, + .state_disk = { + .uV = 1, + .mode = REGULATOR_MODE_STANDBY, + .disabled = 1, + }, + .state_standby = { + .uV = 1, + .mode = REGULATOR_MODE_STANDBY, + .disabled = 1, + }, + + }, + .num_consumer_supplies = ARRAY_SIZE(tps65910_touch_supply), + .consumer_supplies = tps65910_touch_supply, +}; + +/* =========================================================================== */ + +/* --------------------------------------------------------------------------- */ + +/* This one only works if 'always_on' is set to true. Do I need to do something + * special otherwise to turn it on? Maybe the driver doesn't enable it. + * + * The accelerometer driver isn't using regulators properly, hence this needs to + * be always on. + */ + +static struct regulator_consumer_supply tps65910_accel_supply[] = { + REGULATOR_SUPPLY("vdd", "mpu6515"), +}; + +static struct regulator_init_data tps65910_accel = { + .supply_regulator = "VBAT", + .constraints = { + .min_uV = 1800000, + .max_uV = 1800000, + .valid_modes_mask = REGULATOR_MODE_NORMAL | REGULATOR_MODE_IDLE | REGULATOR_MODE_STANDBY, + .valid_ops_mask = REGULATOR_CHANGE_MODE | REGULATOR_CHANGE_STATUS, + .always_on = true, + .apply_uV = true, + + .state_mem = { + .uV = 1, + .mode = REGULATOR_MODE_STANDBY, + .disabled = 1, + }, + .state_disk = { + .uV = 1, + .mode = REGULATOR_MODE_STANDBY, + .disabled = 1, + }, + .state_standby = { + .uV = 1, + .mode = REGULATOR_MODE_STANDBY, + .disabled = 1, + }, + }, + .num_consumer_supplies = ARRAY_SIZE(tps65910_accel_supply), + .consumer_supplies = tps65910_accel_supply, +}; + +/* --------------------------------------------------------------------------- */ +/* Supplies the MPU PD and friends. + */ + +static struct regulator_consumer_supply tps65910_vdd1_supply[] = { + REGULATOR_SUPPLY("vcc", "cpu0"), +}; + +static struct regulator_init_data tps65910_vdd1 = { + .supply_regulator = "VBAT", + .constraints = { + .name = "vdd_mpu_iva", + .min_uV = 900000, + .max_uV = 1350000, + .valid_modes_mask = REGULATOR_MODE_NORMAL, + .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE, + .always_on = false, + + .state_mem = { + .uV = 1, + .mode = REGULATOR_MODE_STANDBY, + .disabled = 1, + }, + .state_disk = { + .uV = 1, + .mode = REGULATOR_MODE_STANDBY, + .disabled = 1, + }, + .state_standby = { + .uV = 1, + .mode = REGULATOR_MODE_STANDBY, + .disabled = 1, + }, + }, + + .num_consumer_supplies = ARRAY_SIZE(tps65910_vdd1_supply), + .consumer_supplies = tps65910_vdd1_supply, +}; + +/* --------------------------------------------------------------------------- */ +/* I seem to need always on, but the TWL code gets by without it. So... + */ + +static struct regulator_consumer_supply tps65910_vdd2_supply[] = { + REGULATOR_SUPPLY("vdd_core", "l3_main.0"), +}; + +static struct regulator_init_data tps65910_vdd2 = { + .supply_regulator = "VBAT", + .constraints = { + .name = "vdd_core", + .min_uV = 900000, + .max_uV = 1200000, + .valid_modes_mask = REGULATOR_MODE_NORMAL, + .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE, + .always_on = false, + + .state_mem = { + .uV = 1, + .mode = REGULATOR_MODE_STANDBY, + .disabled = 1, + }, + .state_disk = { + .uV = 1, + .mode = REGULATOR_MODE_STANDBY, + .disabled = 1, + }, + .state_standby = { + .uV = 1, + .mode = REGULATOR_MODE_STANDBY, + .disabled = 1, + }, + }, + + .num_consumer_supplies = ARRAY_SIZE(tps65910_vdd2_supply), + .consumer_supplies = tps65910_vdd2_supply, +}; + +/* --------------------------------------------------------------------------- */ + +/* The clock has to be ON, probably because we're not enabling it properly. */ +/* If I set i2chs_keepon to 6, UBIfs fails to mount (!?). Again, probably + * not enabling it properly. + * + * And even with therm set, the screen acts weird (looking really dark during + * boot, touch not working when up). + */ + +/* +static struct tps65910_sleep_keepon_data olio_slp_keepon = { + .therm_keepon = 0, + .clkout32k_keepon = 0, + .i2chs_keepon = 1, + };*/ + + + +static struct tps65910_board omap3h1_tps65910_pdata = { + /* .irq = 7 + OMAP_INTC_START, */ /* Getting this at runtime instead. */ + .en_ck32k_xtal = true, + /* .en_dev_slp = true, */ + + /* .slp_keepon = &olio_slp_keepon, */ + + .tps65910_pmic_init_data[TPS65910_REG_VIO] = &tps65910_1v8, + .tps65910_pmic_init_data[TPS65910_REG_VDD1] = &tps65910_vdd1, + .tps65910_pmic_init_data[TPS65910_REG_VDD2] = &tps65910_vdd2, + .tps65910_pmic_init_data[TPS65910_REG_VDIG1] = &tps65910_accel, + .tps65910_pmic_init_data[TPS65910_REG_VDIG2] = &tps65910_touch, + .tps65910_pmic_init_data[TPS65910_REG_VPLL] = &tps65910_vpll, + + .tps65910_pmic_init_data[TPS65910_REG_VMMC] = &tps65910_touch3, + .tps65910_pmic_init_data[TPS65910_REG_VAUX2] = &tps65910_vibrator, + + /* This one is connected to BT ... maybe more? */ + + .tps65910_pmic_init_data[TPS65910_REG_VAUX33] = &tps65910_3v3, + + /* not actually used */ + + .tps65910_pmic_init_data[TPS65910_REG_VRTC] = &tps65910_dummy, + .tps65910_pmic_init_data[TPS65910_REG_VDAC] = &tps65910_dummy, + .tps65910_pmic_init_data[TPS65910_REG_VAUX1] = &tps65910_dummy, /* 2v85 */ + .tps65910_pmic_init_data[TPS65910_REG_VDD3] = &tps65910_dummy, + + .pm_off = true, +}; + + +/* ====================================================================== */ +/* Voltage domain settings */ + + +#define OMAP3_SRI2C_SLAVE_ADDR 0x12 +#define OMAP3_VDD_MPU_SR_CONTROL_REG 0x00 +#define OMAP3_VDD_CORE_SR_CONTROL_REG 0x01 +#define OMAP3_VP_CONFIG_ERROROFFSET 0x00 +#define OMAP3_VP_VSTEPMIN_VSTEPMIN 0x1 +#define OMAP3_VP_VSTEPMAX_VSTEPMAX 0x04 +#define OMAP3_VP_VLIMITTO_TIMEOUT_US 200 + + +static unsigned long olio_vsel_to_uv(const u8 vsel) +{ + return (((vsel * 125) + 6000)) * 100; +} + +static u8 olio_uv_to_vsel(unsigned long uv) +{ + return DIV_ROUND_UP(uv - 600000, 12500); +} + + +static struct omap_voltdm_pmic omap3_mpu_pmic = { + .slew_rate = 12500, + .step_size = 12500, + .vp_erroroffset = OMAP3_VP_CONFIG_ERROROFFSET, + .vp_vstepmin = OMAP3_VP_VSTEPMIN_VSTEPMIN, + .vp_vstepmax = OMAP3_VP_VSTEPMAX_VSTEPMAX, + .vddmin = 900000, + .vddmax = 1350000, + .vp_timeout_us = OMAP3_VP_VLIMITTO_TIMEOUT_US, + .i2c_slave_addr = OMAP3_SRI2C_SLAVE_ADDR, + .volt_reg_addr = OMAP3_VDD_MPU_SR_CONTROL_REG, + .i2c_high_speed = true, + .vsel_to_uv = olio_vsel_to_uv, + .uv_to_vsel = olio_uv_to_vsel, +}; + +static struct omap_voltdm_pmic omap3_core_pmic = { + .slew_rate = 12500, + .step_size = 12500, + .vp_erroroffset = OMAP3_VP_CONFIG_ERROROFFSET, + .vp_vstepmin = OMAP3_VP_VSTEPMIN_VSTEPMIN, + .vp_vstepmax = OMAP3_VP_VSTEPMAX_VSTEPMAX, + .vddmin = 900000, + .vddmax = 1200000, + .vp_timeout_us = OMAP3_VP_VLIMITTO_TIMEOUT_US, + .i2c_slave_addr = OMAP3_SRI2C_SLAVE_ADDR, + .volt_reg_addr = OMAP3_VDD_CORE_SR_CONTROL_REG, + .i2c_high_speed = true, + .vsel_to_uv = olio_vsel_to_uv, + .uv_to_vsel = olio_uv_to_vsel, +}; + +int __init omap3_voltdm_init(void) +{ + struct voltagedomain *voltdm; + + if (!cpu_is_omap34xx()) + return -ENODEV; + + voltdm = voltdm_lookup("mpu_iva"); + omap_voltage_register_pmic(voltdm, &omap3_mpu_pmic); + + voltdm = voltdm_lookup("core"); + omap_voltage_register_pmic(voltdm, &omap3_core_pmic); + + return 0; +} + + + +/* ====================================================================== */ + + +static struct i2c_board_info __initdata omap3h1_i2c1_board_info[] = { + { + I2C_BOARD_INFO("tps65910", 0x2d), + .platform_data = &omap3h1_tps65910_pdata, + }, +#ifdef CONFIG_MACH_OMAP3_H1_DVT2 +}; +static struct i2c_board_info __initdata omap3h1_i2c2_board_info[] = { +#endif + { + I2C_BOARD_INFO("mpu6515", 0x68), + // This is needed for the interrupt wake. IH_GPIO_BASE changed in 3.10 + // .irq = (IH_GPIO_BASE + MPUIRQ_GPIO), + .platform_data = &mpu_data, + }, + { + /* Backlight */ + I2C_BOARD_INFO("lm3530-led", 0x38), + .platform_data = &omap3h1_backlight_platform_data, + }, + { + I2C_BOARD_INFO("mXT224", 0x4a), + .platform_data = &mxt_data, + }, + { + I2C_BOARD_INFO("cm3391", 0x10), + }, +#ifdef CONFIG_MACH_OMAP3_H1_EVT1 +}; +static struct i2c_board_info __initdata omap3h1_i2c3_board_info[] = { +#endif + { + I2C_BOARD_INFO("bq274xx", 0x55), + }, +}; + +#ifdef ONLY_KEEPING_THIS_STUFF_FOR_NOSTALGIC_REASONS + +/* --------------------------------------------------------------------------- */ +/* Create debugfs entry + * + * We need to have this so that our wake-up thread can tell us it's PID. + * That PID will then be used when waking the system up. + */ + +struct dentry * pidfile; + +#define SIG_OLIO_WAKE 44 // we choose 44 as our signal number (real-time signals are in the range of 33 to 64) + +static ssize_t write_pid(struct file *file, + const char __user *buf, + size_t count, + loff_t *ppos) +{ + char mybuf[10]; + int pid = 0; + + /* read the value from user space */ + + if(count > 10) + return -EINVAL; + if (copy_from_user(mybuf, buf, count) != 0) { + /* nothing read?? */ + printk ("OLIO: write_pid: Error??\n"); + return 0; + } + + sscanf(mybuf, "%d", &pid); + + printk("pid read = %d\n", pid); + + acc_wake.user_pid = pid; + + return count; +} + +static ssize_t send_wake_signal (void) { + int ret; + struct siginfo info; + struct task_struct *t; + + /* send the signal */ + + printk ("Now sending signal!\n"); + + memset(&info, 0, sizeof(struct siginfo)); + + /* this is bit of a trickery: SI_QUEUE is normally used by sigqueue from user space, + * and kernel space should use SI_KERNEL. But if SI_KERNEL is used the real_time data + * is not delivered to the user space signal handler function. + */ + + info.si_signo = SIG_OLIO_WAKE; + info.si_code = SI_QUEUE; + + /* real time signals may have 32 bits of data. */ + + info.si_int = 1234; + + rcu_read_lock(); + + t = pid_task(find_pid_ns(acc_wake.user_pid, &init_pid_ns), PIDTYPE_PID); + + if(t == NULL){ + rcu_read_unlock(); + printk("no such pid\n"); + return -ENODEV; + } + + rcu_read_unlock(); + + /* send the signal */ + + ret = send_sig_info(SIG_OLIO_WAKE, &info, t); + + if (ret < 0) { + printk("error sending signal\n"); + } + return ret; +} + +static const struct file_operations h1_fops = { + .write = write_pid, +}; + + +/*************************************************************************** + * acc_irq_handler - handle interrupt from accelerometer + * + * This routine gets called when an interrupt from the accelerometer + * happens. Time out is in milliseconds. + * + * TODO: BREAK this all out, place it in it's own kernel driver together + * with the configuration stuff for the accelerometer (the low power sleep + * mode stuff). + */ + +#define OLIO_DOUBLE_TAP 500 +#define OLIO_ONE_SECOND 1000 +#define OLIO_DT_WAIT 3000 + +static unsigned long previous; +static unsigned long previous_double; + +static irqreturn_t acc_irq_handler_thr(int irq, void * omap3h1_d) { + /* struct platform_device** omap3h1_devs = (struct platform_device **) omap3h1_d; */ + + int ret = 99; + unsigned long now; + + printk (KERN_DEBUG "acc_irq_handler_thr: Entered!\n"); + + now = jiffies; + + if (jiffies_to_msecs(now - previous) < OLIO_DOUBLE_TAP) { + + /* ignore double clicks that happens too soon from the previous one */ + if (jiffies_to_msecs (now - previous_double) < OLIO_DT_WAIT) + { + previous = 0; + return IRQ_HANDLED; + } + + printk (KERN_DEBUG "Double tap detected!\n"); + + /* We want to wake up. Take wake lock (and send signal to user space?) + * BT driver only takes wake lock, then lets higher levels handle + * everything ... but what if there's nothing there to take the lock? + */ + + send_wake_signal(); + wake_lock_timeout (&acc_wake.lock, msecs_to_jiffies (20 * OLIO_ONE_SECOND)); + + previous_double = now; + previous = 0; + } else { + previous = now; + } + + printk (KERN_DEBUG "acc_irq_handler_thr: Leaving! (ret = %d)\n", ret); + + return IRQ_HANDLED; +} + +static irqreturn_t acc_irq_handler(int irq, void * omap3h1_d) { + printk (KERN_DEBUG "acc_irq_handler: Entered!\n"); + + /* nothing to do, other than wake the main thread */ + + printk (KERN_DEBUG "acc_irq_handler: Leaving!\n"); + return IRQ_WAKE_THREAD; +} + +static int __init omap3_acc_irq_init (int irq, void * dev_id) { + irq_set_irq_wake(irq, 1); + + if (request_threaded_irq (irq, acc_irq_handler, + acc_irq_handler_thr, + IRQF_SHARED | IRQF_TRIGGER_RISING, + "acc_wake", + dev_id)) { + printk (KERN_DEBUG "Couldn't register handler for accelerometer IRQ\n"); + } + + /* Should check the return value ... but if it fails, what do we do? */ + + return 0; +} + +static int __init omap3_wake_init (void) { + pidfile = debugfs_create_file("wake_signal_pid", 0200, NULL, NULL, &h1_fops); + acc_wake.user_pid = 0; /* No user thread yet */ + + snprintf(acc_wake.lock_name, sizeof(acc_wake.lock_name), + "Accelerometer"); + wake_lock_init(&acc_wake.lock, WAKE_LOCK_SUSPEND, + acc_wake.lock_name); + return 0; +} + + +#endif /* ONLY_KEEPING_THIS_STUFF_FOR_NOSTALGIC_REASONS */ + + +/*************************************************************************** + * omap_uart data + */ + +/* Some notes: + .dma_enabled = false, + .dma_rx_buf_size = DEFAULT_RXDMA_BUFSIZE, + .dma_rx_poll_rate = DEFAULT_RXDMA_POLLRATE, + .dma_rx_timeout = DEFAULT_RXDMA_TIMEOUT, + .autosuspend_timeout = DEFAULT_AUTOSUSPEND_DELAY, ( -1 or X ms. ) + + .wakelock_timeout - for minnow, this is 150 (BT) or 50 (M4 debug). + Can be left out. + + .DTR_* -> can be left out. I can't find anyone using it. + + int DTR_gpio; + int DTR_inverted; + int DTR_present; + bool wakeup_capable; + + bool open_close_pm; - Minnow uses this for c55 only + unsigned int rx_trig; Minnow, BT & debug only +*/ + +static struct omap_uart_port_info omap_uart_ports[] = { + { + .dma_enabled = false, /* To specify DMA Mode */ + .dma_rx_buf_size = DEFAULT_RXDMA_BUFSIZE, + .dma_rx_timeout = DEFAULT_RXDMA_TIMEOUT, + .dma_rx_poll_rate = DEFAULT_RXDMA_POLLRATE, + .autosuspend_timeout = 5000, + .wakeup_capable = false, + }, + { + .dma_enabled = false, /* To specify DMA Mode */ + .dma_rx_buf_size = DEFAULT_RXDMA_BUFSIZE, + .dma_rx_timeout = DEFAULT_RXDMA_TIMEOUT, + .dma_rx_poll_rate = DEFAULT_RXDMA_POLLRATE, + .autosuspend_timeout = 5000, + .wakeup_capable = false, + }, + { + .dma_enabled = false, /* To specify DMA Mode */ + .dma_rx_buf_size = DEFAULT_RXDMA_BUFSIZE, + .dma_rx_timeout = DEFAULT_RXDMA_TIMEOUT, + .dma_rx_poll_rate = DEFAULT_RXDMA_POLLRATE, + .autosuspend_timeout = -1, + .wakelock_timeout = -1, + .wakeup_capable = true, + }, + { + .dma_enabled = false, /* To specify DMA Mode */ + .dma_rx_buf_size = DEFAULT_RXDMA_BUFSIZE, + .dma_rx_timeout = DEFAULT_RXDMA_TIMEOUT, + .dma_rx_poll_rate = DEFAULT_RXDMA_POLLRATE, + .autosuspend_timeout = 5000, + .wakeup_capable = false, + }, +}; + + +/*************************************************************************** + * DEVICE TREE STUFF + * + * Trying to include some DT stuff with our board file. Not sure how this + * will work out... + */ + +static struct of_device_id omap_dt_match_table[] __initdata = { + { .compatible = "olio,omap3-h1", }, + { .compatible = "simple-bus", }, + { .compatible = "ti,omap-infra", }, + { } +}; + + +/*************************************************************************** + * omap3_h1_i2c_init - init the i2c buses + * + */ + +static int __init omap3_h1_i2c_init(void) +{ + int acc_irq; + + /* In Linux 3.10 we need to request an IRQ through + * gpio_to_irq. This means it can't be set at compile time, and + * must be done at runtime. In other words, here. + */ + + gpio_request_one(ATMEL_MXT_GPIO, GPIOF_IN, "atmel_mxt_ts CHG"); + gpio_request_one(MPUIRQ_GPIO, GPIOF_IN, "mpu6515 IRQ pin"); + + acc_irq = gpio_to_irq(MPUIRQ_GPIO); + +#ifdef CONFIG_MACH_OMAP3_H1_DVT2 + omap3h1_i2c2_board_info[2].irq = gpio_to_irq(ATMEL_MXT_GPIO); + omap3h1_i2c2_board_info[0].irq = acc_irq; + + ((struct tps65910_board *) (omap3h1_i2c1_board_info[0].platform_data))->irq = + gpio_to_irq (TPS_SYS_NIRQ); +#else + omap3h1_i2c1_board_info[3].irq = gpio_to_irq(ATMEL_MXT_GPIO); + omap3h1_i2c1_board_info[1].irq = acc_irq; +#endif + + gpio_request_one(USB_ON_ETK_D7, GPIOF_OUT_INIT_HIGH, "USB on"); + + /* Register buses */ + + omap_register_i2c_bus(1, 400, omap3h1_i2c1_board_info, ARRAY_SIZE(omap3h1_i2c1_board_info)); +#ifdef CONFIG_MACH_OMAP3_H1_DVT2 + omap_register_i2c_bus(2, 400, omap3h1_i2c2_board_info, ARRAY_SIZE(omap3h1_i2c2_board_info)); +#else + omap_register_i2c_bus(2, 400, NULL, 0); +#endif +#ifdef CONFIG_MACH_OMAP3_H1_EVT1 + omap_register_i2c_bus(3, 400, omap3h1_i2c3_board_info, ARRAY_SIZE(omap3h1_i2c3_board_info)); +#else + omap_register_i2c_bus(3, 400, NULL, 0); +#endif + return 0; +} + + +static struct platform_device *omap3h1_devices[] __initdata = { + &omap3h1_vbat, + // &bcm20702_bluetooth_device, + &nop_phy_device, + &omap3h1_dmic_codec, +}; + +#ifdef CONFIG_OMAP_MUX +static struct omap_board_mux board_mux[] __initdata = { + +#if defined(CONFIG_MACH_OMAP3_H1_DVT1) || defined(CONFIG_MACH_OMAP3_H1_DVT2) + OMAP3_MUX(CAM_HS, OMAP_MUX_MODE4 | OMAP_PIN_OUTPUT), +#else + OMAP3_MUX(HSUSB0_DIR, OMAP_MUX_MODE4 | OMAP_PIN_OUTPUT), +#endif + OMAP3_MUX(DSS_PCLK, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_HSYNC, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_VSYNC, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA0, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA1, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA2, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA3, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA4, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA5, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA6, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA7, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA8, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA9, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA10, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA11, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA12, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA13, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA14, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA15, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA16, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(DSS_DATA17, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + + OMAP3_MUX(MCSPI1_CLK, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(MCSPI1_SIMO, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + OMAP3_MUX(MCSPI1_SOMI, OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP), + OMAP3_MUX(MCSPI1_CS1, OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT), + + /* TOUCH_RESET */ + + OMAP3_MUX(CAM_D6, OMAP_MUX_MODE4 | OMAP_PIN_INPUT_PULLUP), + +#if defined(CONFIG_MACH_OMAP3_H1_DVT1) || defined(CONFIG_MACH_OMAP3_H1_DVT2) + /* USB pin settings (mUSB) */ + + OMAP3_MUX(HSUSB0_CLK, (OMAP_MUX_MODE0 | OMAP_PIN_INPUT)), + OMAP3_MUX(HSUSB0_DATA0, (OMAP_MUX_MODE0 | OMAP_PIN_INPUT)), + OMAP3_MUX(HSUSB0_DATA1, (OMAP_MUX_MODE0 | OMAP_PIN_INPUT)), + OMAP3_MUX(HSUSB0_DATA2, (OMAP_MUX_MODE0 | OMAP_PIN_INPUT)), + OMAP3_MUX(HSUSB0_DATA3, (OMAP_MUX_MODE0 | OMAP_PIN_INPUT)), + OMAP3_MUX(HSUSB0_DATA4, (OMAP_MUX_MODE0 | OMAP_PIN_INPUT)), + OMAP3_MUX(HSUSB0_DATA5, (OMAP_MUX_MODE0 | OMAP_PIN_INPUT)), + OMAP3_MUX(HSUSB0_DATA6, (OMAP_MUX_MODE0 | OMAP_PIN_INPUT)), + OMAP3_MUX(HSUSB0_DATA7, (OMAP_MUX_MODE0 | OMAP_PIN_INPUT)), + OMAP3_MUX(HSUSB0_DIR, (OMAP_MUX_MODE0 | OMAP_PIN_INPUT)), + OMAP3_MUX(HSUSB0_NXT, (OMAP_MUX_MODE0 | OMAP_PIN_INPUT)), + OMAP3_MUX(HSUSB0_STP, (OMAP_MUX_MODE0 | OMAP_PIN_OUTPUT)), +#endif /* CONFIG_MACH_OMAP3_H1_DVT */ + + /* accelerometer */ + + OMAP3_MUX(JTAG_EMU1, (OMAP_MUX_MODE4 | OMAP_PIN_INPUT + | OMAP_PIN_OFF_WAKEUPENABLE)), + + /* USB on */ + + OMAP3_MUX(ETK_D7, (OMAP_MUX_MODE4 | OMAP_PIN_OUTPUT)), + + OMAP3_MUX(SYS_NIRQ, (OMAP_MUX_MODE0 | OMAP_PIN_INPUT)), + + { .reg_offset = OMAP_MUX_TERMINATOR }, +}; +#endif + +static void __init omap3_h1_init(void) +{ + /* Read what we can from the device tree */ + + of_platform_populate(NULL, omap_dt_match_table, NULL, NULL); + + board_nand_init(omap3h1_nand_partitions, + ARRAY_SIZE(omap3h1_nand_partitions), NAND_CS, + NAND_BUSWIDTH_16, NULL); + + omap_sdrc_init(mt29c4g48_sdrc_params, mt29c4g48_sdrc_params); + + omap3_mux_init(board_mux, OMAP_PACKAGE_CBP); + + omap3_h1_i2c_init(); + + /* Set up the voltage domains */ + omap3_voltdm_init(); + + platform_add_devices(omap3h1_devices, ARRAY_SIZE(omap3h1_devices)); + + omap3h1_spi_init(); + + omap_serial_board_init(omap_uart_ports); + + omap_display_init(&omap3h1_dss_data); + + usb_bind_phy("musb-hdrc.0.auto", 0, "nop_usb_xceiv"); /* "tusb-usb-h1" */ + + usb_musb_init(&musb_board_data); + + /* #ifdef ONLY_KEEPING_THIS_STUFF_FOR_NOSTALGIC_REASONS */ + + /* For handling interrupts from the accelerometer */ + + /* previous = jiffies; */ + + /* Init the code that handles wake ups */ + + /* + omap3_wake_init(); + + omap3_acc_irq_init(omap3h1_i2c2_board_info[0].irq, (void *) &omap3h1_devices); + */ + + /* #endif ONLY_KEEPING_THIS_STUFF_FOR_NOSTALGIC_REASONS*/ + +} + +static const char *omap3_h1_boards_compat[] __initdata = { + "olio,omap3-h1", + NULL, +}; + +DT_MACHINE_START(OMAP3_H1, "Olio OMAP3 H1 (Flattened Device Tree)") + .atag_offset = 0x100, + .reserve = omap_reserve, + .map_io = omap3_map_io, + .init_early = omap3630_init_early, + /* .init_irq = omap3_init_irq, */ + .init_irq = omap_intc_of_init, + .handle_irq = omap3_intc_handle_irq, + .init_machine = omap3_h1_init, + .init_late = omap3630_init_late, + .init_time = omap3_sync32k_timer_init, + /* .init_time = omap3_secure_sync32k_timer_init, */ + .dt_compat = omap3_h1_boards_compat, + .restart = omap3xxx_restart, +MACHINE_END + +#if 0 /* removing ... for now */ +MACHINE_START(OMAP3_H1, "Olio OMAP3 H1 Board") + .atag_offset = 0x100, + .reserve = omap_reserve, + .map_io = omap3_map_io, + .init_early = omap3630_init_early, + .init_irq = omap3_init_irq, + .handle_irq = omap3_intc_handle_irq, + .init_machine = omap3_h1_init, + .init_late = omap3630_init_late, + .init_time = omap3_sync32k_timer_init, + /* .init_time = omap3_secure_sync32k_timer_init, */ + /* .dt_compat = omap3_h1_boards_compat, */ + .restart = omap3xxx_restart, +MACHINE_END +#endif |