Google Git
Sign in
nest-open-source / nest-guard / 1.0 / linux / 6754b876e4c89285b30ff59800d23e21ce2dbe3f / . / linux / arch / arm / mach-omap2 / board-diamond.c
blob: f884f229dfe435a60b5ecc675bb2faeb9538724f [file] [log] [blame]
/*
* Copyright (c) 2010-2012 Nest Labs, Inc.
*
* Author: Grant Erickson <grant@nestlabs.com>
*
* 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.
*
* Description:
* This file is the core Linux board support file for the Nest
* Diamond board. It was originally cloned from the Texas
* Instruments OMAP3 EVM board file.
*
* SDRAM Controller (SDRC):
* - Samsung K4X51163PI-FCG6 512 Mb x 16 (64 MiB) DDR SDRAM
* - Nanya NT6D 512Mb x 16 (64MiB) DDR SDRAM
*
* General Purpose Memory Controller (GPMC):
* - Micron MT29F2G16ABDHC-ET 256 MiB SLC NAND Flash (Development)
* - Micron MT29F2G16ABBEAH4 256 MiB SLC NAND Flash (Non-development)
* - Samsung K9F4G08U0C 512 MiB SLC NAND Flash (Development Only)
* - SMSC LAN9220 10/100 Mbit Ethernet MAC and PHY (Development Only)
*
* Multimedia Card (MMC) Interface:
* - Molex 500998-0900 Secure Digital (SD) Connector (Development Only)
* - Wireless LAN (WLAN) Module
*
* Display Subsystem (DSS):
* - Samsung LMS350DF03 HVGA (320 x 480) LCM (Development and Prototype)
* - Tianma TM025ZDZ01 (320 x 320) LCM (Production)
*
* Camera Image Signal Processor:
* - Unused
*
* Inter-Integrated Circuit (I2C) Controller:
* - Channel 1:
* * Texas Instruments TPS65921 Power Management Unit (PMU)
*
* - Channel 2:
* * Silicon Labs 1143 Proximity / Ambient Light Sensor (Development Only)
* * Avago ADBS A330 Optical Finger Navigation (OFN) Sensor (Non-development)
*
* - Channel 3:
* * Unused
*
* - Channel 4:
* * Texas Instruments TPS65921 Power Management Unit (PMU)
*
* UART Controller:
* - Channel 1:
* * Head Unit Serial Console
*
* - Channel 2:
* * ZigBee Wireless Module
*
* Multichannel Buffered Serial Port (McBSP):
* - Channel 1:
* * Unused
*
* - Channel 2:
* * Unused
*
* - Channel 3:
* * UART2
*
* - Channel 4:
* * Unavailable
*
* - Channel 5:
* * Unavailable
*
* Multichannel Serial Peripheral Interface (McSPI):
* - Channel 1:
* * Unused
*
* - Channel 2:
* * Samsung LMS350DF03 HVGA (320 x 480) LCM (Development and Prototype)
* * Tianma TM025ZDZ01 (320 x 320) LCM (Production)
*
* - Channel 3:
* * Unavailable
*
* Interrupt Controller:
* - SMSC LAN9220 10/100 Mbit Ethernet MAC and PHY (Development Only)
* - Si1143 Proximity / Ambient Light Sensor (Development Only)
*
* GPIO Controller:
* - Bank 1:
* - Bank 2:
* * 2.11 (43) Samsung LMS350DF03 LCD 1.8V to 3.3V Buffer #Enable (Development Only)
*
* - Bank 3:
* - Bank 4:
* * 4.5 (101) Samsung LMS350DF03 LCD 3.3V Supply Enable (Development Only)
* * 4.13 (109) Samsung LMS350DF03 LCD #Reset
*
* - Bank 5:
* - Bank 6:
*
* - Backplate Detect
* - Battery Disconnect
* - ZigBee Wireless Module
*/
#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/gpio.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/backlight.h>
#include <linux/pwm_backlight.h>
#include <linux/omapfb.h>
#include <linux/si1143.h>
#include <linux/spi/spi.h>
#include <linux/spi/ili9481.h>
#include <linux/spi/lms350df03.h>
#include <linux/spi/s6d05a1.h>
#include <linux/wl12xx.h>
#include <linux/i2c/twl.h>
#include <linux/usb/otg.h>
#include <linux/usb/dynamic.h>
#include <linux/usb/msc.h>
#include <linux/smsc911x.h>
#include <linux/rotary_encoder_lite.h>
#include <linux/rtc.h>
#include <linux/adbs-a330.h>
#include <linux/mmc/host.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/partitions.h>
#include <linux/mtd/nand.h>
#include <linux/regulator/consumer.h>
#include <linux/regulator/fixed.h>
#include <linux/regulator/machine.h>
#include <linux/input/pwm-beeper.h>
#include <linux/lm3530_bl.h>
#include <linux/lm3530_bl.h>
#include <linux/r61529a1.h>
#include <mach/board-diamond-gpio.h>
#include <mach/board-j49-gpio.h>
#include <mach/hardware.h>
#include <asm/system.h>
#include <asm/mach-types.h>
#include <asm/mach/arch.h>
#include <asm/mach/map.h>
#include <plat/board.h>
#include <plat/onenand.h>
#include <plat/gpmc.h>
#include <plat/nand.h>
#include <plat/common.h>
#include <plat/usb.h>
#include <plat/mcspi.h>
#include <plat/clock.h>
#include <plat/omap-pm.h>
#include <plat/display.h>
#include <plat/pwm.h>
#include "mux.h"
#include "hsmmc.h"
#include "sdram-samsung-k4x51163pi-nanya-nt6d.h"
#include "pm.h"
#include "prm-regbits-34xx.h"
#include "board-diamond-battery.h"
#include "board-diamond-backplate.h"
#include "board-diamond-nlmodel.h"
#include "control.h"
#include "board-diamond-zigbee.h"
/* Preprocessor Definitions */
#define diamond_gpio_try_request(gpio, string, action) \
if (unlikely(gpio_request(gpio, string))) { \
printk(KERN_ERR \
"Failed to request GPIO %u " string "\n", gpio); \
action; \
} \
#define diamond_gpio_try_output(gpio, value, action) \
do { \
diamond_gpio_try_request(gpio, #gpio, action); \
if (gpio_direction_output(gpio, value) < 0) { \
printk(KERN_ERR \
"Could not set GPIO %u " #gpio \
" as an output with value %u\n", \
gpio, value); \
action; \
} \
} while (0)
#define diamond_gpio_try_input(gpio, action) \
do { \
diamond_gpio_try_request(gpio, #gpio, action); \
if (gpio_direction_input(gpio) < 0) { \
printk(KERN_ERR \
"Could not set GPIO %u " #gpio \
" as an input\n", gpio); \
action; \
} \
} while (0)
#define machine_warn(format, ...) pr_warning("Machine: " format, ## __VA_ARGS__)
#define machine_info(format, ...) pr_info("Machine: " format, ## __VA_ARGS__)
#define GPMC_CS0_BASE 0x60
#define GPMC_CS_SIZE 0x30
#define DIAMOND_ETHR_START 0x2c000000
#define DIAMOND_ETHR_SIZE 1024
#define DIAMOND_ETHR_ID_REV 0x50
#define DIAMOND_SMSC911X_CS 5
#define DIAMOND_BACKLIGHT_PWM_ID 0
#define DIAMOND_PIEZO_PWM_ID 1
#define DIAMOND_ADBS_A330_VDDA_SUPPLY "vdda"
#define DIAMOND_ADBS_A330_VDDA_UV 3000000
#define NEST_USB_VENDOR_STRING "Nest"
#define DIAMOND_USB_VENDOR_STRING NEST_USB_VENDOR_STRING
#define DIAMOND_USB_PRODUCT_STRING "Learning Thermostat"
#define DIAMOND_USB_SERIAL_STRING_SIZE ((sizeof(u64) * 2) + 1)
#define J49_USB_VENDOR_STRING NEST_USB_VENDOR_STRING
#define J49_USB_PRODUCT_STRING "Learning Thermostat"
#define J49_USB_SERIAL_STRING_SIZE ((sizeof(u64) * 2) + 1)
#define NEST_USB_VENDOR_ID 0x2464
#define DIAMOND_USB_VENDOR_ID 0x2464
#define DIAMOND_USB_PRODUCT_ID 0x0001
#define J49_USB_VENDOR_ID 0x2464
#define J49_USB_PRODUCT_ID 0x0002
/* NOTE: SCSI Inquiry (which is how USB Mass Storage Class (MSC)
* vendor and product strings are queried), are limited to 8 and 16
* ASCII characters, for vendor and product, respectively.
*/
#define DIAMOND_MSC_VENDOR_STRING "Nest"
#define DIAMOND_MSC_PRODUCT_STRING "Nest"
#define DIAMOND_MSC_RELEASE 1
/* Type Definitions */
enum {
DIAMOND_SPI_LCD,
J49_SPI_DEV
};
enum {
DIAMOND_DEVELOPMENT_DATA = 0,
DIAMOND_1_4_DATA = 1,
DIAMOND_1_5_DATA = 2,
DIAMOND_1_6_DATA = 3,
DIAMOND_1_7_DATA = 4,
DIAMOND_1_8_DATA = 5,
DIAMOND_1_9_DATA = 6,
DISPLAY_2_0_DATA = 7,
DISPLAY_2_1_DATA = 8,
DISPLAY_2_2_DATA = 9,
DISPLAY_2_3_DATA = 10,
DISPLAY_2_4_DATA = 11,
DISPLAY_2_11_DATA = 12
};
struct diamond_init_data {
const char *name;
void (*add_devices)(void);
void (*backplate_init)(const struct nlmodel *model);
void (*clk_init)(void);
void (*display_init)(void);
void (*flash_init)(void);
void (*i2c_init)(void);
void (*mmc_init)(void);
void (*mux_init)(void);
void (*net_init)(void);
void (*piezo_init)(void);
void (*power_init)(void);
void (*regulator_init)(void);
void (*serial_init)(void);
void (*spi_init)(void);
void (*usb_init)(void);
};
static struct omap_musb_board_data musb_board_data = {
.interface_type = MUSB_INTERFACE_ULPI,
.mode = MUSB_PERIPHERAL,
.power = 50,
};
/* Function Prototypes */
extern void twl4030_poweroff(void);
static int diamond_development_enable_lcd(struct omap_dss_device *dssdev);
static void diamond_development_disable_lcd(struct omap_dss_device *dssdev);
static int diamond_backlight_notify(struct device *dev, int brightness);
static void __init diamond_backplate_init(const struct nlmodel *model);
static void __init diamond_clk_init(void);
static void __init diamond_flash_init(void);
static void __init diamond_irq_init(void);
static void __init diamond_serial_init(void);
static void __init diamond_usb_init(void);
static void __init diamond_development_add_devices(void);
static void __init diamond_development_display_init(void);
static void __init diamond_development_i2c_init(void);
static void __init diamond_development_mmc_init(void);
static void __init diamond_development_mux_init(void);
static void __init diamond_development_net_init(void);
static void __init diamond_development_regulator_init(void);
static void __init diamond_development_spi_init(void);
static void __init diamond_1_4_add_devices(void);
static void __init diamond_1_4_display_init(void);
static void __init diamond_1_4_i2c_init(void);
static void __init diamond_1_4_mmc_init(void);
static void __init diamond_1_4_mux_init(void);
static void __init diamond_1_4_net_init(void);
static void __init diamond_1_4_piezo_init(void);
static void __init diamond_1_4_regulator_init(void);
static void __init diamond_1_4_spi_init(void);
static void __init diamond_1_4_power_init(void);
static void __init diamond_1_5_add_devices(void);
static void __init diamond_1_5_display_init(void);
static void __init diamond_1_5_i2c_init(void);
static void __init diamond_1_5_mmc_init(void);
static void __init diamond_1_5_mux_init(void);
static void __init diamond_1_5_net_init(void);
static void __init diamond_1_5_piezo_init(void);
static void __init diamond_1_5_regulator_init(void);
static void __init diamond_1_5_spi_init(void);
static void __init diamond_1_6_add_devices(void);
static void __init diamond_1_6_i2c_init(void);
static void __init diamond_1_6_mux_init(void);
static void __init diamond_1_6_power_init(void);
static void __init diamond_1_7_add_devices(void);
static void __init diamond_1_7_mux_init(void);
static void __init diamond_1_7_spi_init(void);
static void __init display_2_0_add_devices(void);
static void __init display_2_0_i2c_init(void);
static void __init display_2_0_mux_init(void);
static void __init display_2_0_spi_init(void);
static void __init display_2_0_net_init(void);
static void __init display_2_1_mux_init(void);
static void __init display_2_11_display_init(void);
static void __init display_2_11_regulator_init(void);
/* Global Variables */
static const char *diamond_family = "Diamond";
static const int diamond_product_default = 1;
static const int diamond_revision_default = 10;
static const char *j49_family = "Display";
static const int j49_product_default = 2;
static struct diamond_init_data diamond_development_data __initdata = {
.name = "Development",
.add_devices = diamond_development_add_devices,
.backplate_init = diamond_backplate_init,
.clk_init = diamond_clk_init,
.display_init = diamond_development_display_init,
.flash_init = diamond_flash_init,
.i2c_init = diamond_development_i2c_init,
.mmc_init = diamond_development_mmc_init,
.mux_init = diamond_development_mux_init,
.net_init = diamond_development_net_init,
.piezo_init = NULL,
.power_init = NULL,
.regulator_init = diamond_development_regulator_init,
.serial_init = diamond_serial_init,
.spi_init = diamond_development_spi_init,
.usb_init = diamond_usb_init
};
static struct diamond_init_data diamond_1_4_data __initdata = {
.name = "Prototype",
.add_devices = diamond_1_4_add_devices,
.backplate_init = diamond_backplate_init,
.clk_init = diamond_clk_init,
.display_init = diamond_1_4_display_init,
.flash_init = diamond_flash_init,
.i2c_init = diamond_1_4_i2c_init,
.mmc_init = diamond_1_4_mmc_init,
.mux_init = diamond_1_4_mux_init,
.net_init = diamond_1_4_net_init,
.piezo_init = diamond_1_4_piezo_init,
.power_init = diamond_1_4_power_init,
.regulator_init = diamond_1_4_regulator_init,
.serial_init = diamond_serial_init,
.spi_init = diamond_1_4_spi_init,
.usb_init = diamond_usb_init
};
static struct diamond_init_data diamond_1_5_data __initdata = {
.name = "Prototype",
.add_devices = diamond_1_5_add_devices,
.backplate_init = diamond_backplate_init,
.clk_init = diamond_clk_init,
.display_init = diamond_1_5_display_init,
.flash_init = diamond_flash_init,
.i2c_init = diamond_1_5_i2c_init,
.mmc_init = diamond_1_5_mmc_init,
.mux_init = diamond_1_5_mux_init,
.net_init = diamond_1_5_net_init,
.piezo_init = diamond_1_5_piezo_init,
.power_init = diamond_1_4_power_init,
.regulator_init = diamond_1_5_regulator_init,
.serial_init = diamond_serial_init,
.spi_init = diamond_1_5_spi_init,
.usb_init = diamond_usb_init
};
static struct diamond_init_data diamond_1_6_data __initdata = {
.name = "EVT",
.add_devices = diamond_1_6_add_devices,
.backplate_init = diamond_backplate_init,
.clk_init = diamond_clk_init,
.display_init = diamond_1_5_display_init,
.flash_init = diamond_flash_init,
.i2c_init = diamond_1_6_i2c_init,
.mmc_init = diamond_1_5_mmc_init,
.mux_init = diamond_1_6_mux_init,
.net_init = diamond_1_5_net_init,
.piezo_init = diamond_1_5_piezo_init,
.power_init = diamond_1_6_power_init,
.regulator_init = diamond_1_5_regulator_init,
.serial_init = diamond_serial_init,
.spi_init = diamond_1_5_spi_init,
.usb_init = diamond_usb_init
};
static struct diamond_init_data diamond_1_7_data __initdata = {
.name = "DVT",
.add_devices = diamond_1_7_add_devices,
.backplate_init = diamond_backplate_init,
.clk_init = diamond_clk_init,
.display_init = diamond_1_5_display_init,
.flash_init = diamond_flash_init,
.i2c_init = diamond_1_6_i2c_init,
.mmc_init = diamond_1_5_mmc_init,
.mux_init = diamond_1_7_mux_init,
.net_init = diamond_1_5_net_init,
.piezo_init = diamond_1_5_piezo_init,
.power_init = diamond_1_6_power_init,
.regulator_init = diamond_1_5_regulator_init,
.serial_init = diamond_serial_init,
.spi_init = diamond_1_7_spi_init,
.usb_init = diamond_usb_init
};
static struct diamond_init_data display_2_0_data __initdata = {
.name = "Prototype",
.add_devices = display_2_0_add_devices,
.backplate_init = diamond_backplate_init,
.clk_init = diamond_clk_init,
.display_init = diamond_1_5_display_init,
.flash_init = diamond_flash_init,
.i2c_init = display_2_0_i2c_init,
.mmc_init = diamond_1_5_mmc_init,
.mux_init = display_2_0_mux_init,
.net_init = display_2_0_net_init,
.piezo_init = diamond_1_5_piezo_init,
.power_init = diamond_1_6_power_init,
.regulator_init = diamond_1_5_regulator_init,
.serial_init = diamond_serial_init,
.spi_init = display_2_0_spi_init,
.usb_init = diamond_usb_init
};
static struct diamond_init_data display_2_1_data __initdata = {
.name = "EVT",
.add_devices = display_2_0_add_devices,
.backplate_init = diamond_backplate_init,
.clk_init = diamond_clk_init,
.display_init = diamond_1_5_display_init,
.flash_init = diamond_flash_init,
.i2c_init = display_2_0_i2c_init,
.mmc_init = diamond_1_5_mmc_init,
.mux_init = display_2_1_mux_init,
.net_init = display_2_0_net_init,
.piezo_init = diamond_1_5_piezo_init,
.power_init = diamond_1_6_power_init,
.regulator_init = diamond_1_5_regulator_init,
.serial_init = diamond_serial_init,
.spi_init = display_2_0_spi_init,
.usb_init = diamond_usb_init
};
static struct diamond_init_data display_2_2_data __initdata = {
.name = "DVT",
.add_devices = display_2_0_add_devices,
.backplate_init = diamond_backplate_init,
.clk_init = diamond_clk_init,
.display_init = diamond_1_5_display_init,
.flash_init = diamond_flash_init,
.i2c_init = display_2_0_i2c_init,
.mmc_init = diamond_1_5_mmc_init,
.mux_init = display_2_1_mux_init,
.net_init = display_2_0_net_init,
.piezo_init = diamond_1_5_piezo_init,
.power_init = diamond_1_6_power_init,
.regulator_init = diamond_1_5_regulator_init,
.serial_init = diamond_serial_init,
.spi_init = display_2_0_spi_init,
.usb_init = diamond_usb_init
};
static struct diamond_init_data display_2_3_data __initdata = {
.name = "Pre-PVT",
.add_devices = display_2_0_add_devices,
.backplate_init = diamond_backplate_init,
.clk_init = diamond_clk_init,
.display_init = diamond_1_5_display_init,
.flash_init = diamond_flash_init,
.i2c_init = display_2_0_i2c_init,
.mmc_init = diamond_1_5_mmc_init,
.mux_init = display_2_1_mux_init,
.net_init = display_2_0_net_init,
.piezo_init = diamond_1_5_piezo_init,
.power_init = diamond_1_6_power_init,
.regulator_init = diamond_1_5_regulator_init,
.serial_init = diamond_serial_init,
.spi_init = display_2_0_spi_init,
.usb_init = diamond_usb_init
};
static struct diamond_init_data display_2_4_data __initdata = {
.name = "PVT",
.add_devices = display_2_0_add_devices,
.backplate_init = diamond_backplate_init,
.clk_init = diamond_clk_init,
.display_init = diamond_1_5_display_init,
.flash_init = diamond_flash_init,
.i2c_init = display_2_0_i2c_init,
.mmc_init = diamond_1_5_mmc_init,
.mux_init = display_2_1_mux_init,
.net_init = display_2_0_net_init,
.piezo_init = diamond_1_5_piezo_init,
.power_init = diamond_1_6_power_init,
.regulator_init = diamond_1_5_regulator_init,
.serial_init = diamond_serial_init,
.spi_init = display_2_0_spi_init,
.usb_init = diamond_usb_init
};
static struct diamond_init_data display_2_11_data __initdata = {
.name = "D2D",
.add_devices = display_2_0_add_devices,
.backplate_init = diamond_backplate_init,
.clk_init = diamond_clk_init,
.display_init = display_2_11_display_init,
.flash_init = diamond_flash_init,
.i2c_init = display_2_0_i2c_init,
.mmc_init = diamond_1_5_mmc_init,
.mux_init = display_2_1_mux_init,
.net_init = display_2_0_net_init,
.piezo_init = diamond_1_5_piezo_init,
.power_init = diamond_1_6_power_init,
.regulator_init = display_2_11_regulator_init,
.serial_init = diamond_serial_init,
.spi_init = display_2_0_spi_init,
.usb_init = diamond_usb_init
};
static struct diamond_init_data *diamond_init_data[] __initdata = {
[DIAMOND_DEVELOPMENT_DATA] = &diamond_development_data,
[DIAMOND_1_4_DATA] = &diamond_1_4_data,
[DIAMOND_1_5_DATA] = &diamond_1_5_data,
[DIAMOND_1_6_DATA] = &diamond_1_6_data,
[DIAMOND_1_7_DATA] = &diamond_1_7_data,
[DIAMOND_1_8_DATA] = &diamond_1_7_data,
[DIAMOND_1_9_DATA] = &diamond_1_7_data,
[DISPLAY_2_0_DATA] = &display_2_0_data,
[DISPLAY_2_1_DATA] = &display_2_1_data,
[DISPLAY_2_2_DATA] = &display_2_2_data,
[DISPLAY_2_3_DATA] = &display_2_3_data,
[DISPLAY_2_4_DATA] = &display_2_4_data,
[DISPLAY_2_11_DATA] = &display_2_11_data
};
static bool lcd_enabled = false;
#if defined(CONFIG_HAVE_PWM)
/* OMAP-specific implementations of generic PWM devices required to
* support the OMAP PWM-driven backlight and piezo devices.
*/
static struct omap2_pwm_platform_config diamond_backlight_pwm_config = {
.timer_id = 10, // GPT10_PWM_EVT
.polarity = 1 // Active-high
};
static struct omap2_pwm_platform_config diamond_piezo_pwm_config = {
.timer_id = 11, // GPT11_PWM_EVT
.polarity = 1 // Active-high
};
static struct platform_device diamond_backlight_pwm_device = {
.name = "omap-pwm",
.id = DIAMOND_BACKLIGHT_PWM_ID,
.dev = {
.platform_data = &diamond_backlight_pwm_config,
},
};
static struct platform_device diamond_piezo_pwm_device = {
.name = "omap-pwm",
.id = DIAMOND_PIEZO_PWM_ID,
.dev = {
.platform_data = &diamond_piezo_pwm_config,
},
};
#endif /* defined(CONFIG_HAVE_PWM) */
static struct twl4030_ins __initdata sleep_on_seq[] = {
/* Turn OFF VAUX2 */
{MSG_SINGULAR(DEV_GRP_P1, RES_VAUX2, RES_STATE_OFF), 2},
/* Turn off HFCLKOUT */
{MSG_SINGULAR(DEV_GRP_P1, RES_HFCLKOUT, RES_STATE_OFF), 2},
/* Turn OFF VDD1 */
{MSG_SINGULAR(DEV_GRP_P1, RES_VDD1, RES_STATE_OFF), 2},
/* Turn OFF VDD2 */
{MSG_SINGULAR(DEV_GRP_P1, RES_VDD2, RES_STATE_OFF), 2},
/* Turn OFF VPLL1 */
{MSG_SINGULAR(DEV_GRP_P1, RES_VPLL1, RES_STATE_OFF), 2},
};
static struct twl4030_script __initdata sleep_on_script = {
.script = sleep_on_seq,
.size = ARRAY_SIZE(sleep_on_seq),
.flags = TWL4030_SLEEP_SCRIPT,
};
/*
* This script instructs twl4030 to first enable CLKEN, then wakeup the
* regulators and then all other resources.
*/
static struct twl4030_ins __initdata wakeup_seq[] = {
/* Turn on VAUX2 */
{MSG_SINGULAR(DEV_GRP_P1, RES_VAUX2, RES_STATE_ACTIVE), 2},
/* Turn on HFCLKOUT */
{MSG_SINGULAR(DEV_GRP_P1, RES_HFCLKOUT, RES_STATE_ACTIVE), 2},
/* Turn ON VDD1 */
{MSG_SINGULAR(DEV_GRP_P1, RES_VDD1, RES_STATE_ACTIVE), 2},
/* Turn ON VDD2 */
{MSG_SINGULAR(DEV_GRP_P1, RES_VDD2, RES_STATE_ACTIVE), 2},
/* Turn ON VPLL1 */
{MSG_SINGULAR(DEV_GRP_P1, RES_VPLL1, RES_STATE_ACTIVE), 2},
};
static struct twl4030_script __initdata wakeup_script = {
.script = wakeup_seq,
.size = ARRAY_SIZE(wakeup_seq),
.flags = TWL4030_WAKEUP12_SCRIPT | TWL4030_WAKEUP3_SCRIPT,
};
static struct twl4030_ins __initdata wrst_seq[] = {
{MSG_SINGULAR(DEV_GRP_ALL, RES_RESET, RES_STATE_OFF), 0x2},
{MSG_SINGULAR(DEV_GRP_ALL, RES_Main_Ref, RES_STATE_WRST), 0x2},
{MSG_BROADCAST(DEV_GRP_ALL, RES_GRP_ALL, 0, 0x2, RES_STATE_WRST), 0x2},
{MSG_SINGULAR(DEV_GRP_ALL, RES_VUSB_3V1, RES_STATE_WRST), 0x2},
{MSG_SINGULAR(DEV_GRP_P1, RES_VAUX2, RES_STATE_WRST), 0x2},
{MSG_SINGULAR(DEV_GRP_P1, RES_VPLL1, RES_STATE_WRST), 0x2},
{MSG_SINGULAR(DEV_GRP_P1, RES_VDD2, RES_STATE_WRST), 0x7},
{MSG_SINGULAR(DEV_GRP_P1, RES_VDD1, RES_STATE_WRST), 0x25},
{MSG_BROADCAST(DEV_GRP_NULL, RES_GRP_RC, 7, 0, RES_STATE_WRST), 0x2},
{MSG_SINGULAR(DEV_GRP_ALL, RES_RESET, RES_STATE_ACTIVE), 0x2},
};
static struct twl4030_script __initdata wrst_script = {
.script = wrst_seq,
.size = ARRAY_SIZE(wrst_seq),
.flags = TWL4030_WRST_SCRIPT,
};
static struct twl4030_script __initdata *twl4030_scripts[] = {
&wakeup_script,
&sleep_on_script,
&wrst_script
};
/*
* Setting the devgroup enables the regulator. VAUX2 is the only one
* that we're not using the default voltage, so we set its inital group
* to NULL. This way it won't turn on until after we set its voltage
* at registration.
*/
static struct twl4030_resconfig __initdata diamond_twl4030_rconfig[] = {
{ .resource = RES_VPLL1, .devgroup = DEV_GRP_P1, .type = 3,
.type2 = 1, .remap_sleep = RES_STATE_OFF },
{ .resource = RES_VINTANA1, .devgroup = DEV_GRP_ALL, .type = 1,
.type2 = 2, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_VINTANA2, .devgroup = DEV_GRP_ALL, .type = 0,
.type2 = 2, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_VINTDIG, .devgroup = DEV_GRP_ALL, .type = 1,
.type2 = 2, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_VIO, .devgroup = DEV_GRP_ALL, .type = 2,
.type2 = 2, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_VAUX2, .devgroup = DEV_GRP_NULL,
.type = 3, .type2 = 1, .remap_sleep = RES_STATE_OFF },
{ .resource = RES_VDD1, .devgroup = DEV_GRP_P1,
.type = 4, .type2 = 1, .remap_sleep = RES_STATE_OFF },
{ .resource = RES_VDD2, .devgroup = DEV_GRP_P1,
.type = 3, .type2 = 1, .remap_sleep = RES_STATE_OFF },
{ .resource = RES_REGEN, .devgroup = DEV_GRP_ALL, .type = 2,
.type2 = 1, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_NRES_PWRON, .devgroup = DEV_GRP_ALL, .type = 0,
.type2 = 1, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_CLKEN, .devgroup = DEV_GRP_ALL, .type = 3,
.type2 = 2, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_SYSEN, .devgroup = DEV_GRP_ALL, .type = 6,
.type2 = 1, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_HFCLKOUT, .devgroup = DEV_GRP_P3,
.type = 0, .type2 = 2, .remap_sleep = RES_STATE_SLEEP },
{ 0, 0},
};
/*
* This is identical to that of diamond except for turning off VMMC1
*/
static struct twl4030_resconfig __initdata j49_twl4030_rconfig[] = {
{ .resource = RES_VPLL1, .devgroup = DEV_GRP_P1, .type = 3,
.type2 = 1, .remap_sleep = RES_STATE_OFF },
{ .resource = RES_VINTANA1, .devgroup = DEV_GRP_ALL, .type = 1,
.type2 = 2, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_VINTANA2, .devgroup = DEV_GRP_ALL, .type = 0,
.type2 = 2, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_VINTDIG, .devgroup = DEV_GRP_ALL, .type = 1,
.type2 = 2, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_VIO, .devgroup = DEV_GRP_ALL, .type = 2,
.type2 = 2, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_VAUX2, .devgroup = DEV_GRP_NULL,
.type = 3, .type2 = 1, .remap_sleep = RES_STATE_OFF },
{ .resource = RES_VDD1, .devgroup = DEV_GRP_P1,
.type = 4, .type2 = 1, .remap_sleep = RES_STATE_OFF },
{ .resource = RES_VDD2, .devgroup = DEV_GRP_P1,
.type = 3, .type2 = 1, .remap_sleep = RES_STATE_OFF },
{ .resource = RES_REGEN, .devgroup = DEV_GRP_ALL, .type = 2,
.type2 = 1, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_NRES_PWRON, .devgroup = DEV_GRP_ALL, .type = 0,
.type2 = 1, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_CLKEN, .devgroup = DEV_GRP_ALL, .type = 3,
.type2 = 2, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_SYSEN, .devgroup = DEV_GRP_ALL, .type = 6,
.type2 = 1, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_HFCLKOUT, .devgroup = DEV_GRP_P3,
.type = 0, .type2 = 2, .remap_sleep = RES_STATE_SLEEP },
{ .resource = RES_VMMC1, .devgroup = DEV_GRP_NULL,
.type = 2, .type2 = 1, .remap_sleep = RES_STATE_OFF },
{ 0, 0},
};
static struct twl4030_power_data __initdata diamond_tps65921_scripts_data = {
.scripts = twl4030_scripts,
.num = ARRAY_SIZE(twl4030_scripts),
.resource_config = diamond_twl4030_rconfig,
};
static struct twl4030_power_data __initdata j49_tps65921_scripts_data = {
.scripts = twl4030_scripts,
.num = ARRAY_SIZE(twl4030_scripts),
.resource_config = j49_twl4030_rconfig,
};
/*
* XXX - Diamond does not actually have or use any OneNAND. However,
* the way OMAP board support is written in this kernel, removing any
* data and code associated with OneNAND from our board results in a
* kernel panic. So, we leave this as-is for now until we can debug
* the root cause.
*/
static struct mtd_partition diamond_onenand_partitions[] = {
{
.name = "xloader-onenand",
.offset = 0,
.size = 4*(64*2048),
.mask_flags = MTD_WRITEABLE
},
{
.name = "uboot-onenand",
.offset = MTDPART_OFS_APPEND,
.size = 15*(64*2048),
.mask_flags = MTD_WRITEABLE
},
{
.name = "params-onenand",
.offset = MTDPART_OFS_APPEND,
.size = 1*(64*2048),
},
{
.name = "linux-onenand",
.offset = MTDPART_OFS_APPEND,
.size = 40*(64*2048),
},
{
.name = "jffs2-onenand",
.offset = MTDPART_OFS_APPEND,
.size = MTDPART_SIZ_FULL,
},
};
static struct omap_onenand_platform_data diamond_onenand_data = {
.parts = diamond_onenand_partitions,
.nr_parts = ARRAY_SIZE(diamond_onenand_partitions),
.dma_channel = -1, /* disable DMA in OMAP OneNAND driver */
};
/*
* Diamond NAND flash parition sizes.
*
* For "raw" partitions, any size evenly divisible by the NAND erase
* block size (generally 128 KiB) is acceptable.
*
* For JFFS2 file system partitions, there's quite a bit of metadata
* overhead with JFFS2, so any size smaller than 4 MiB is practically
* useless as overhead at that size is just about less than 50%.
*/
#define DIAMOND_IPL_RAW_NAND_SIZE ( 256 << 10) // 256 KiB
#define DIAMOND_SPL_RAW_NAND_SIZE (1536 << 10) // 1.5 MiB (x2)
#define DIAMOND_ENV_RAW_NAND_SIZE ( 384 << 10) // 384 KiB (x2)
#define DIAMOND_BOOT_RAW_NAND_SIZE ( 8 << 20) // 8 MiB (x2)
#define DIAMOND_ROOT_FS_NAND_SIZE ( 46 << 20) // 46 MiB (x2)
#define DIAMOND_SYSTEM_CONFIG_FS_NAND_SIZE ( 4 << 20) // 4 MiB
#define DIAMOND_USER_CONFIG_FS_NAND_SIZE ( 8 << 20) // 8 MiB
#define DIAMOND_DATA_FS_NAND_SIZE ( 20 << 20) // 20 MiB
#define DIAMOND_LOG_FS_NAND_SIZE ( 20 << 20) // 20 MiB
#define DIAMOND_SCRATCH_FS_NAND_SIZE ( 92 << 20) // 92 MiB
static struct mtd_partition diamond_nand_partitions[] = {
// First, one partition for the entire device.
{
.name = "nand0",
.offset = 0,
.size = MTDPART_SIZ_FULL
},
// Then, partitions by functional use overlaid on the whole device.
//
// Initial- and secondary-program loader-related partitions. These
// are generally expected to stay constant with increasing NAND
// density.
{
.name = "ipl",
.offset = 0,
.size = DIAMOND_IPL_RAW_NAND_SIZE,
},
{
.name = "spl0",
.offset = MTDPART_OFS_APPEND,
.size = DIAMOND_SPL_RAW_NAND_SIZE
},
{
.name = "spl1",
.offset = MTDPART_OFS_APPEND,
.size = DIAMOND_SPL_RAW_NAND_SIZE
},
{
.name = "env0",
.offset = MTDPART_OFS_APPEND,
.size = DIAMOND_ENV_RAW_NAND_SIZE
},
{
.name = "env1",
.offset = MTDPART_OFS_APPEND,
.size = DIAMOND_ENV_RAW_NAND_SIZE
},
// Kernel- and file system-related partitions. These are generally
// expected to grow with increasing NAND density.
{
.name = "boot0",
.offset = MTDPART_OFS_APPEND,
.size = DIAMOND_BOOT_RAW_NAND_SIZE
},
{
.name = "root0",
.offset = MTDPART_OFS_APPEND,
.size = DIAMOND_ROOT_FS_NAND_SIZE
},
{
.name = "boot1",
.offset = MTDPART_OFS_APPEND,
.size = DIAMOND_BOOT_RAW_NAND_SIZE
},
{
.name = "root1",
.offset = MTDPART_OFS_APPEND,
.size = DIAMOND_ROOT_FS_NAND_SIZE
},
{
.name = "system-config",
.offset = MTDPART_OFS_APPEND,
.size = DIAMOND_SYSTEM_CONFIG_FS_NAND_SIZE
},
{
.name = "user-config",
.offset = MTDPART_OFS_APPEND,
.size = DIAMOND_USER_CONFIG_FS_NAND_SIZE
},
{
.name = "data",
.offset = MTDPART_OFS_APPEND,
.size = DIAMOND_DATA_FS_NAND_SIZE
},
{
.name = "log",
.offset = MTDPART_OFS_APPEND,
.size = DIAMOND_LOG_FS_NAND_SIZE
},
{
.name = "scratch",
.offset = MTDPART_OFS_APPEND,
.size = DIAMOND_SCRATCH_FS_NAND_SIZE
}
};
static struct omap_nand_platform_data diamond_nand_data = {
.parts = diamond_nand_partitions,
.nr_parts = ARRAY_SIZE(diamond_nand_partitions),
.nand_setup = NULL,
.dma_channel = -1, /* disable DMA in OMAP NAND driver */
.dev_ready = NULL,
};
/*
* The TI OMAP frame buffer (OMAPFB) driver has a number of different
* ways of allocating frame buffer memory to its various frame buffer
* devices. Unfortunately, they are not fully unified with the generic
* Linux frame buffer driver.
*
* Regardless, one such method is specifiying the parameters on the
* kernel command line. For example, the following would instruct the
* generic linux frame buffer driver to allocate 4 MiB of memory and
* to then allocate all of it to the OMAP frame buffer zero (0),
* typically the LCD:
*
* vram=4M omapfb.vram=0:4M
*
* Another method is to programmatically use platform data. Because we
* do not need any dynamism in this area and because we elect to
* minimize futzing with kernel command line parameters, we take the
* platform data approach.
*
* Because the frame buffer is a virtual entity, all the parameters
* specified here are in terms of virtual sizes and depths and may not
* actually reflect the capabilities of the LCD itself.
*
* The parameters below basically define a double-buffered 320 x 320
* (or 480) frame at 4 bytes per pixel.
*/
#define DIAMOND_VFB_BPP 4
#define DIAMOND_VFB_COUNT 2
#define DIAMOND_VFB_ROUND (512 << 10)
static struct omapfb_platform_data diamond_320_320_omapfb_config = {
.mem_desc = {
.region_cnt = 1,
.region[0] = {
.paddr = 0,
.size = diamond_roundup(320 * 320 *
DIAMOND_VFB_BPP *
DIAMOND_VFB_COUNT,
DIAMOND_VFB_ROUND),
}
},
.lcd ={
.rotation = 0
}
};
static struct omapfb_platform_data diamond_320_480_omapfb_config = {
.mem_desc = {
.region_cnt = 1,
.region[0] = {
.paddr = 0,
.size = diamond_roundup(320 * 480 *
DIAMOND_VFB_BPP *
DIAMOND_VFB_COUNT,
DIAMOND_VFB_ROUND)
}
}
};
#if defined(CONFIG_PANEL_SAMSUNG_LMS350DF03)
static struct lms350df03_platform_data lms350df03_development_lcd_config = {
.reset = {
.gpio = DIAMOND_GPIO_LCD_RESETB,
.inverted = false
},
.regulator = {
.vcc = NULL,
},
};
static struct lms350df03_platform_data lms350df03_prototype_lcd_config = {
.reset = {
.gpio = DIAMOND_GPIO_LCD_RESETB,
.inverted = false
},
.regulator = {
.vcc = "lcd2v8",
},
};
#define LMS350DF03_LCD_MODALIAS "lms350df03"
#define LMS350DF03_LCD_SPI_MAX_SPEED 10000000
#endif /* defined(CONFIG_PANEL_SAMSUNG_LMS350DF03) */
#if defined(CONFIG_PANEL_GIANTPLUS_GPM1145A0)
static struct ili9481_platform_data ili9481_lcd_config = {
.reset = {
.gpio = DIAMOND_GPIO_LCD_RESETB,
.inverted = false
}
};
#define ILI9481_LCD_MODALIAS "ili9481"
#define ILI9481_LCD_SPI_MAX_SPEED 8000000
#endif /* defined(CONFIG_PANEL_GIANTPLUS_GPM1145A0) */
#if defined(CONFIG_PANEL_TIANMA_TM025ZDZ01)
static struct s6d05a1_platform_data s6d05a1_lcd_config = {
.reset = {
.gpio = DIAMOND_GPIO_LCD_RESETB,
.inverted = false
},
.lcd_id = {
.gpio = DIAMOND_GPIO_LCD_ID,
},
.regulator = {
.vcc = "lcd2v8",
},
// The Tianma display is mounted and oriented such that its
// natural position is upside down. So, set x- and y-mirroring to
// effect a 180 degree rotation.
.orientation = {
.x_mirror = true,
.y_mirror = true,
.x_y_exchange = false
}
};
#define TM025ZDZ01_LCD_MODALIAS "s6d05a1"
#define TM025ZDZ01_LCD_SPI_MAX_SPEED 10000000
#endif /* defined(CONFIG_PANEL_TIANMA_TM025ZDZ01) */
#define SPI_DEV_MODALIAS "spidev"
#define SPI_DEV_MAX_SPEED 1000000
static struct omap2_mcspi_device_config lcd_mcspi_config = {
.turbo_mode = false,
.single_channel = 0
};
static struct spi_board_info diamond_development_spi_board_info[] = {
[DIAMOND_SPI_LCD] = {
#if defined(CONFIG_PANEL_SAMSUNG_LMS350DF03)
.modalias = LMS350DF03_LCD_MODALIAS,
.bus_num = 2,
.chip_select = 0,
.max_speed_hz = LMS350DF03_LCD_SPI_MAX_SPEED,
.controller_data = &lcd_mcspi_config,
.platform_data = &lms350df03_development_lcd_config
#endif
}
};
static struct spi_board_info diamond_1_4_spi_board_info[] = {
[DIAMOND_SPI_LCD] = {
#if defined(CONFIG_PANEL_SAMSUNG_LMS350DF03)
.modalias = LMS350DF03_LCD_MODALIAS,
.bus_num = 2,
.chip_select = 0,
.max_speed_hz = LMS350DF03_LCD_SPI_MAX_SPEED,
.controller_data = &lcd_mcspi_config,
.platform_data = &lms350df03_prototype_lcd_config
#endif
}
};
/*
* Starting with EVT revisions, displays transition for form-factor
* Tianma TM025ZDZ01 displays.
*/
static struct spi_board_info diamond_1_5_spi_board_info[] = {
[DIAMOND_SPI_LCD] = {
.modalias = TM025ZDZ01_LCD_MODALIAS,
.bus_num = 2,
.chip_select = 0,
.max_speed_hz = TM025ZDZ01_LCD_SPI_MAX_SPEED,
.controller_data = &lcd_mcspi_config,
.platform_data = &s6d05a1_lcd_config
}
};
/*
* Starting with DVT revisions, displays move to McSPI1 from McSPI2
* to accomodate bi-directional SPI communication.
*/
static struct spi_board_info diamond_1_7_spi_board_info[] = {
[DIAMOND_SPI_LCD] = {
.modalias = TM025ZDZ01_LCD_MODALIAS,
.bus_num = 1,
.chip_select = 0,
.max_speed_hz = TM025ZDZ01_LCD_SPI_MAX_SPEED,
.controller_data = &lcd_mcspi_config,
.platform_data = &s6d05a1_lcd_config
}
};
/*
* Starting with DVT revisions, displays move to McSPI1 from McSPI2
* to accomodate bi-directional SPI communication.
*/
static struct spi_board_info display_2_0_spi_board_info[] = {
[DIAMOND_SPI_LCD] = {
.modalias = TM025ZDZ01_LCD_MODALIAS,
.bus_num = 1,
.chip_select = 0,
.max_speed_hz = TM025ZDZ01_LCD_SPI_MAX_SPEED,
.controller_data = &lcd_mcspi_config,
.platform_data = &s6d05a1_lcd_config
},
[J49_SPI_DEV] = {
.modalias = SPI_DEV_MODALIAS,
.bus_num = 2,
.chip_select = 0,
.max_speed_hz = SPI_DEV_MAX_SPEED,
}
};
static struct omap_dss_device diamond_development_lcd_device = {
.name = "Samsung LMS350DF03",
.driver_name = "samsung_lms350df03",
.phy.dpi.data_lines = 24,
.type = OMAP_DISPLAY_TYPE_DPI,
.platform_enable = diamond_development_enable_lcd,
.platform_disable = diamond_development_disable_lcd,
};
static struct omap_dss_device diamond_1_4_lcd_device = {
.name = "Samsung LMS350DF03",
.driver_name = "samsung_lms350df03",
.phy.dpi.data_lines = 24,
.type = OMAP_DISPLAY_TYPE_DPI,
.platform_enable = NULL,
.platform_disable = NULL,
};
static struct omap_dss_device diamond_1_5_lcd_device = {
.name = "Tianma TM025ZDZ01",
.driver_name = "tianma_tm025zdz01",
.phy.dpi.data_lines = 24,
.type = OMAP_DISPLAY_TYPE_DPI,
.platform_enable = NULL,
.platform_disable = NULL,
};
/*
tast = 0
taht = 10
tcs = 20
trcs = 170
tcsf= 20
twc = 50
twrh = 20
twrl = 20
trc = 450
trdh = 250
trdl = 170
twds = 15
twdh = 15
tracc = 150
trod = 10
*/
static struct omap_dss_device display_2_11_lcd_device = {
.name = "Renesas R61529a1",
.driver_name = "renesas_r61529a1",
.phy.rfbi.data_lines = 16,
.phy.rfbi.channel = OMAP_DSS_CHANNEL_LCD,
.ctrl.pixel_size = 24,
.ctrl.rfbi_timings = {
.cs_on_time = 0,
.cs_off_time = (250+170)*1000,
.we_on_time = 20*1000,
.we_off_time = (40)*1000,
.re_on_time = 250*1000,
.re_off_time = (250+170)*1000,
.we_cycle_time = (52)*1000,
.re_cycle_time = (250+170)*1000,
.cs_pulse_width = (250+170+50)*1000,
.access_time = (250+170)*1000,
},
.type = OMAP_DISPLAY_TYPE_DBI,
.panel.timings = {
.x_res = 320,
.y_res = 320,
.pixel_clock = 7180,
.hsw = 2,
.hfp = 8,
.hbp = 8,
.vsw = 2,
.vfp = 8,
.vbp = 8,
},
.platform_enable = NULL,
.platform_disable = NULL,
};
static struct r61529a1_platform_data r61529a1_config = {
.reset = {
.gpio = DIAMOND_GPIO_LCD_RESETB,
.inverted = false
},
.regulator = {
.vcc = "lcd2v8",
},
};
/*
* Both the devices array and the device data will get fixed up in the
* model-specific display initialization function.
*/
static struct omap_dss_device *diamond_dss_devices[] = {
NULL,
};
static struct omap_dss_board_info diamond_dss_data = {
.num_devices = ARRAY_SIZE(diamond_dss_devices),
.devices = diamond_dss_devices,
.default_device = NULL,
};
static struct platform_device diamond_dss_device = {
.name = "omapdss",
.id = -1,
.dev = {
.platform_data = &diamond_dss_data
},
};
#if defined(CONFIG_WILINK) || defined(CONFIG_WILINK_MODULE)
static struct platform_device diamond_wl1271_device = {
.name = "tiwlan_pm_driver",
.id = -1,
.dev = {
.platform_data = NULL,
},
};
static struct platform_device diamond_wl127x_device = {
.id = 1,
.dev = {
.bus = &platform_bus_type,
},
};
#endif /* defined(CONFIG_WILINK) || defined(CONFIG_WILINK_MODULE) */
#if defined(CONFIG_WL12XX) || defined(CONFIG_WL12XX_MODULE)
static struct wl12xx_platform_data diamond_wl12xx_data __initdata = {
.irq = -1,
.use_eeprom = false,
.pwr_in_suspend = true,
};
#endif /* defined(CONFIG_WL12XX) || defined(CONFIG_WL12XX_MODULE) */
/*
* Generic PWM backlight platform data and device data
*
* The TPS61042 constant current LED drivers which ultimately drives
* the backlight can handle, per its datasheet "TPS61042: Constant
* Current LED Driver", a PWM input in the frequency range 100 Hz to
* 50 KHz (period 10 ms to 20 us).
*
* Per "Control (CTRL)", Page 10 of the datasheet, to enable the
* device, the TPS61042 CTRL signal must be high for 50 us (50000
* ns). The PWM signal can then be applied with a pulse width (tp)
* greater or smaller than tON. To force the device into shutdown
* mode, the CTRL signal must be low for at least 32 ms (32000000 ns).
*
* However, also per "Control (CTRL)", Page 10 of the datasheet, to
* enable the device when the pulse width <= 2.5 us, run with a pulse
* > 2.5 us for 512 PWM cycles. Experimentally, this method does not
* work and, in fact, requires a pulse of 8.1 us, which causes a
* bright flash with white pixels.
*/
#define TPS61042_DISABLE_NS_MIN 32000000
#define TPS61042_ENABLE_NS_MIN 100000
#define TPS61042_PULSE_NS_MIN 400
#define PWM_BL_PERIOD_NS_100_HZ 10000000
#define PWM_BL_PERIOD_NS_50_KHZ 20000
#define TPS61042_PWM_PERIOD_NS_MIN PWM_BL_PERIOD_NS_50_KHZ
#define TPS61042_PWM_PERIOD_NS_MAX PWM_BL_PERIOD_NS_100_HZ
/* Starting at pulse width smaller than this value requires a soft
* start. Datasheet says 2500ns, feedback from TI is to double that
*/
#define TPS61042_START_PULSE_NS_MIN 5000
/* Measured minimum soft start time is 210ms, feedback from TI is
* to add 50%. This value should be independent of soft start
* frequency, but based on my testing that is false.
*/
#define TPS61042_START_MS_MIN 315
/* Soft start algorithm from TI is to use 100Hz, 0.5% duty cycle. If
* increase from 100Hz, must also increase the duty cycle.
*/
#define TPS61042_START_PWM_PERIOD_NS PWM_BL_PERIOD_NS_100_HZ
#define TPS61042_START_PULSE_NS ((TPS61042_START_PWM_PERIOD_NS/1000)*5)
/* The following backight PWM periods are a sampling of periods that
* have been experimentally tried. Those in or just in the super-audio
* frequency range (>= 20 KHz) avoid audible "whine" but also meet the
* TPS61042 pulse width minimum at the number of brightness steps
* chosen (100).
*/
#define PWM_BL_PERIOD_NS_1_0_KHZ 1000000
#define PWM_BL_PERIOD_NS_2_0_KHZ 500000
#define PWM_BL_PERIOD_NS_3_2_KHZ 312500
#define PWM_BL_PERIOD_NS_4_0_KHZ 250000
#define PWM_BL_PERIOD_NS_7_4_KHZ 135000
#define PWM_BL_PERIOD_NS_7_7_KHZ 130000
#define PWM_BL_PERIOD_NS_8_3_KHZ 120000
#define PWM_BL_PERIOD_NS_10_0_KHZ 100000
#define PWM_BL_PERIOD_NS_20_0_KHZ 50000
#define PWM_BL_PERIOD_NS_20_5_KHZ 48780
#define PWM_BL_PERIOD_NS_21_0_KHZ 47619
#define PWM_BL_PERIOD_NS_22_0_KHZ 45455
#define PWM_BL_PERIOD_NS_22_2_KHZ 45000
#define PWM_BL_PERIOD_NS_24_0_KHZ 41667
#define PWM_BL_PERIOD_NS_25_0_KHZ 40000
static struct platform_pwm_backlight_data diamond_tps61042_backlight_data = {
// Generic PWM timer ID to request
.pwm_id = DIAMOND_BACKLIGHT_PWM_ID,
// The maximum and default brightness values, without units. These
// effectively provide the number of possible backlight brightness
// steps.
.max_brightness = 100,
.dft_brightness = 50,
// The PWM period, in nanoseconds.
.pwm_period_ns = PWM_BL_PERIOD_NS_2_0_KHZ,
// The TPS61042 LED driver-specific parameters. Based on our
// frequency and steps, we have a pulse of 450 ns at 1% which
// means we have to specify not only the enable minimum but also
// an initial start pulse train.
.driver = {
.enable_ns = TPS61042_ENABLE_NS_MIN,
.pulse_min_ns = TPS61042_PULSE_NS_MIN,
.start_pulse_min_ns = TPS61042_START_PULSE_NS_MIN,
.start_pulse_ns = TPS61042_START_PULSE_NS,
.start_ms = TPS61042_START_MS_MIN,
.start_period_ns = TPS61042_START_PWM_PERIOD_NS
},
// At this point, we don't have an eye response ramp.
.ramp = NULL,
// Board-specific callback when the backlight changes.
.notify = diamond_backlight_notify,
};
static struct platform_device diamond_tps61042_backlight_device = {
.name = "pwm-backlight",
.dev = {
.platform_data = &diamond_tps61042_backlight_data,
},
};
static struct lm3530_platform_data j49_lm3530_backlight_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 = LM3530_RAMP_LAW_EXP,
.brt_ramp_fall = LM3530_RAMP_TIME_2s,
.brt_ramp_rise = LM3530_RAMP_TIME_2s,
.als1_resistor_sel = LM3530_ALS_IMPD_13_53kOhm,
.als2_resistor_sel = LM3530_ALS_IMPD_Z,
.als_vmin = 730, /* mV */
.als_vmax = 1020, /* mV */
.max_brightness = 0x78,
.dft_brightness = 0x6c,
.enable_gpio = J49_GPIO_LCD_BL_HWEN,
.wait_for_framebuffer = "omapfb"
};
static struct platform_device j49_lm3530_backlight_device = {
.name = "lm3530-backlight",
.dev = {
},
};
static struct i2c_board_info __initdata j49_backlight_i2c_info[] = {
{
I2C_BOARD_INFO("lm3530-backlight", 0x36),
.platform_data = &j49_lm3530_backlight_data,
},
};
#if defined(CONFIG_INPUT_GPIO_ROTARY_ENCODER_LITE)
static struct rotary_encoder_lite_platform_data rotary_enc = {
.gpio_a = DIAMOND_GPIO_ROTARY_VALID,
.gpio_b = DIAMOND_GPIO_ROTARY_DIR,
.gpio_clear = DIAMOND_GPIO_ROTARY_CLEAR,
.steps = 360,
.rollover = 1
};
static struct platform_device diamond_rotary_device = {
.name = "rotary-encoder-lite",
.dev = {
.platform_data = &rotary_enc,
},
};
#endif /* defined(CONFIG_INPUT_GPIO_ROTARY_ENCODER_LITE) */
static int diamond_prototype_piezo_init(struct device *dev)
{
const unsigned int enabled = 0;
diamond_gpio_try_output(DIAMOND_GPIO_PIEZO_NENABLE,
!enabled,
goto fail);
return 0;
fail:
return -EBUSY;
}
static void diamond_prototype_piezo_exit(struct device *dev)
{
gpio_free(DIAMOND_GPIO_PIEZO_NENABLE);
}
static void diamond_prototype_piezo_notify(struct device *dev, int hz)
{
const unsigned int enabled = 0;
gpio_set_value(DIAMOND_GPIO_PIEZO_NENABLE, hz ? enabled : !enabled);
}
static struct platform_pwm_beeper_data diamond_pwm_beeper_data = {
.pwm_id = DIAMOND_PIEZO_PWM_ID,
.init = NULL,
.exit = NULL,
.notify = NULL,
};
static struct platform_device diamond_piezo_device = {
.name = "pwm-beeper",
.id = -1,
.dev = {
.platform_data = &diamond_pwm_beeper_data,
},
};
static struct platform_device diamond_backplate_device = {
.name = "diamond-backplate",
.id = -1,
};
static struct platform_device diamond_battery_device = {
.name = "diamond-battery",
.id = -1,
};
static struct diamond_zigbee_platform_data diamond_zigbee_data = {
.reset_gpio = DIAMOND_GPIO_ZIGBEE_RESET_L,
.pwr_enable_gpio = DIAMOND_GPIO_ZIGBEE_PWR_ENABLE,
.interrupt_gpio = 0
};
static struct platform_device diamond_zigbee_device = {
.name = "diamond-zigbee",
.id = -1,
.dev = {
.platform_data = &diamond_zigbee_data,
},
};
static struct diamond_zigbee_platform_data j49_zigbee_data = {
.reset_gpio = DIAMOND_GPIO_ZIGBEE_RESET_L,
.pwr_enable_gpio = 0,
.interrupt_gpio = J49_GPIO_ZIGBEE_INTERRUPT_L,
};
static struct platform_device j49_zigbee_device = {
.name = "diamond-zigbee",
.id = -1,
.dev = {
.platform_data = &j49_zigbee_data,
},
};
#if defined(CONFIG_SENSORS_TWL4030_MADC)
static struct platform_device diamond_madc_hwmon_device = {
.name = "twl4030_madc_hwmon"
};
#endif
#define ONENAND_MAP 0x20000000 /* OneNand flash */
//Function taken from board_nand_init in board-flash.h
void __init diamond_nand_init(void)
{
diamond_nand_data.cs = 0;
diamond_nand_data.parts = diamond_nand_partitions;
diamond_nand_data.nr_parts = ARRAY_SIZE(diamond_nand_partitions);
diamond_nand_data.devsize = NAND_BUSWIDTH_16;
diamond_nand_data.gpmc_irq = OMAP_GPMC_IRQ_BASE;
diamond_nand_data.ecc_opt = OMAP_ECC_BCH4_CODE_HW;
if (gpmc_nand_init(&diamond_nand_data) < 0)
printk(KERN_ERR "Unable to register NAND device\n");
}
static void __init diamond_onenand_init(void)
{
gpmc_onenand_init(&diamond_onenand_data);
}
static void __init diamond_flash_init(void)
{
diamond_nand_init();
diamond_onenand_init();
}
#if (defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE))
static struct resource diamond_smsc911x_resources[] = {
[0] = {
.start = DIAMOND_ETHR_START,
.end = (DIAMOND_ETHR_START + DIAMOND_ETHR_SIZE - 1),
.flags = IORESOURCE_MEM,
},
[1] = {
.start = OMAP_GPIO_IRQ(DIAMOND_GPIO_ENET_IRQ),
.end = OMAP_GPIO_IRQ(DIAMOND_GPIO_ENET_IRQ),
.flags = (IORESOURCE_IRQ | IRQF_TRIGGER_LOW),
},
};
static struct smsc911x_platform_config smsc911x_config = {
.phy_interface = PHY_INTERFACE_MODE_MII,
.irq_polarity = SMSC911X_IRQ_POLARITY_ACTIVE_LOW,
.irq_type = SMSC911X_IRQ_TYPE_OPEN_DRAIN,
.flags = (SMSC911X_USE_32BIT | SMSC911X_SAVE_MAC_ADDRESS),
};
static struct platform_device diamond_smsc911x_device = {
.name = "smsc911x",
.id = -1,
.num_resources = ARRAY_SIZE(diamond_smsc911x_resources),
.resource = &diamond_smsc911x_resources[0],
.dev = {
.platform_data = &smsc911x_config,
},
};
static inline void __init diamond_smsc911x_init(void)
{
diamond_gpio_try_input(DIAMOND_GPIO_ENET_IRQ, goto done);
platform_device_register(&diamond_smsc911x_device);
done:
return;
}
#endif /* (defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)) */
static void __init diamond_wlan_init(void)
{
#if defined(CONFIG_WILINK) || defined(CONFIG_WILINK_MODULE)
/* Create proxy platform device and alias for MMC2 clock,
* required for WiLink driver.
*/
dev_set_name(&diamond_wl127x_device.dev, "mmci-omap-hs.%d", 1);
clk_add_alias("ick", "tiwlan_pm_driver", "ick", &diamond_wl127x_device.dev);
clk_add_alias("fck", "tiwlan_pm_driver", "fck", &diamond_wl127x_device.dev);
#endif
}
static void __init diamond_display_gpio_init(void)
{
// Attempt to request GPIO outputs for the platform-specific
// aspects of the LCD control interface, including the 3.3V LCM
// Vdd enable (active high) and 1.8V to 3.3V buffer enable (active
// low).
diamond_gpio_try_output(DIAMOND_GPIO_LCD_NENABLE_BUFFER,
1,
goto done);
diamond_gpio_try_output(DIAMOND_GPIO_LCD_ENABLE_VDD,
0,
goto err_1);
// If we are here, we successfully requested all LCM GPIOs.
goto done;
// One of the GPIO requests failed, bail out and release any
// requested GPIOs.
err_1:
gpio_free(DIAMOND_GPIO_LCD_NENABLE_BUFFER);
done:
return;
}
static int diamond_development_enable_lcd(struct omap_dss_device *dssdev)
{
int status = 0;
if (lcd_enabled) {
return (status);
}
// First, enable (active high) the 3.3V supply and wait a few
// milliseconds.
gpio_set_value(DIAMOND_GPIO_LCD_ENABLE_VDD, 1);
mdelay(30);
// Second, enable (active low) the 1.8V to 3.3V signal buffer and
// wait a few milliseconds.
gpio_set_value(DIAMOND_GPIO_LCD_NENABLE_BUFFER, 0);
mdelay(30);
lcd_enabled = true;
return (status);
}
static void diamond_development_disable_lcd(struct omap_dss_device *dssdev)
{
if (!lcd_enabled) {
goto done;
}
// Second, disable (active low) the 1.8V to 3.3V signal buffer.
gpio_set_value(DIAMOND_GPIO_LCD_NENABLE_BUFFER, 1);
// Finally, disable (active high) the 3.3V supply.
gpio_set_value(DIAMOND_GPIO_LCD_ENABLE_VDD, 0);
lcd_enabled = false;
done:
return;
}
static void diamond_1_6_power_off(void)
{
diamond_battery_disconnect(true);
}
static void diamond_1_6_halt_system(void)
{
// reset the backplate
diamond_backplate_reset();
// power off
twl4030_poweroff();
}
/**
* diamond_backlight_notify - backlight change notification callback
* @brightness: the brightness value the backlight PWM will be changed to.
*
* This routine is called whenever a backlight value change
* occurs. Nominally, this routine simply returns the changed
* backlight value, unmodified.
*
* However, in the future, this routine could be used to linearize the
* backlight response in a platform-specific way or to quantize the
* allowed backlight levels.
*
* Returns the backlight PWM value to change to.
*/
static int diamond_backlight_notify(struct device *dev, int brightness)
{
return brightness;
}
static struct regulator_consumer_supply diamond_development_vaux2_supplies[] = {
REGULATOR_SUPPLY("hsusb1", NULL),
};
/*
* This will get fixed up in the model-specific regulator initialization
* function.
*/
static struct regulator_consumer_supply diamond_prototype_vaux2_supplies[] = {
REGULATOR_SUPPLY("hsusb1", NULL),
REGULATOR_SUPPLY("lcd2v8", NULL),
};
static struct regulator_init_data diamond_vaux2 = {
.constraints = {
.min_uV = 2800000,
.max_uV = 2800000,
.apply_uV = true,
.boot_on = true,
.initial_mode = REGULATOR_MODE_NORMAL,
.valid_modes_mask = REGULATOR_MODE_NORMAL
| REGULATOR_MODE_STANDBY,
.valid_ops_mask = REGULATOR_CHANGE_MODE
| REGULATOR_CHANGE_STATUS,
},
.num_consumer_supplies = 0,
.consumer_supplies = NULL,
};
/*
* We only define one MMC channel even though two are supported and used.
* The TI WiLink driver currently in use has it's own SDIO driver which
* plays outside the normal Linux driver space. Consequently, we cannot
* normally define the second MMC channel and have the WiLink driver bind
* to it.
*/
static struct omap2_hsmmc_info diamond_development_tps65921_mmc[] = {
#if defined(CONFIG_MMC_BLOCK)
{
.mmc = 1,
.caps = MMC_CAP_4_BIT_DATA,
.gpio_cd = -EINVAL,
.gpio_wp = 63,
.cover_only = true,
.ocr_mask = 0,
},
#endif /* defined(CONFIG_MMC_BLOCK) */
#if !defined(CONFIG_WILINK) && !defined(CONFIG_WILINK_MODULE)
{
.name = "wl1271",
.mmc = 2,
.caps = MMC_CAP_4_BIT_DATA | MMC_CAP_POWER_OFF_CARD
| MMC_PM_KEEP_POWER,
.gpio_cd = -EINVAL,
.gpio_wp = -EINVAL,
.cover_only = false,
.ext_clock = false,
.nonremovable = true,
.power_saving = false,
.transceiver = false,
.ocr_mask = 0,
},
#endif /* !defined(CONFIG_WILINK) && !defined(CONFIG_WILINK_MODULE) */
{} /* Terminator */
};
static struct omap2_hsmmc_info diamond_prototype_tps65921_mmc[] = {
#if !defined(CONFIG_WILINK) && !defined(CONFIG_WILINK_MODULE)
{
.name = "wl1271",
.mmc = 2,
.caps = MMC_CAP_4_BIT_DATA | MMC_CAP_POWER_OFF_CARD
| MMC_PM_KEEP_POWER,
.gpio_cd = -EINVAL,
.gpio_wp = -EINVAL,
.cover_only = false,
.ext_clock = false,
.nonremovable = true,
.power_saving = false,
.transceiver = false,
.ocr_mask = 0,
},
#endif /* !defined(CONFIG_WILINK) && !defined(CONFIG_WILINK_MODULE) */
{} /* Terminator */
};
static struct twl4030_gpio_platform_data diamond_tps65921_gpio_data = {
.gpio_base = OMAP_MAX_GPIO_LINES,
.irq_base = TWL4030_GPIO_IRQ_BASE,
.irq_end = TWL4030_GPIO_IRQ_END,
};
static struct twl4030_usb_data diamond_tps65921_usb_data = {
.usb_mode = T2_USB_MODE_ULPI,
};
#if defined(CONFIG_USB_OHCI_HCD) || defined(CONFIG_USB_OHCI_HCD_MODULE)
static struct ohci_hcd_omap_platform_data diamond_ohci_pdata __initdata = {
.port_mode[0] = OMAP_OHCI_PORT_MODE_UNUSED,
.port_mode[1] = OMAP_OHCI_PORT_MODE_PHY_4PIN_DPDM,
.port_mode[2] = OMAP_OHCI_PORT_MODE_UNUSED,
};
#endif // defined(CONFIG_USB_OHCI_HCD) || defined(CONFIG_USB_OHCI_HCD_MODULE)
#if defined(CONFIG_USB_DYNAMIC)
static const char *diamond_dynamic_usb_functions[] = {
#if defined(CONFIG_USB_DYNAMIC_MASS_STORAGE)
"usb_mass_storage",
#endif
#if defined(CONFIG_USB_DYNAMIC_ACM)
"acm",
#endif
};
static char diamond_serial_number[DIAMOND_USB_SERIAL_STRING_SIZE] = "";
static const struct dynamic_usb_product diamond_dynamic_usb_products[] = {
{
.product_id = DIAMOND_USB_PRODUCT_ID,
.num_functions = ARRAY_SIZE(diamond_dynamic_usb_functions),
.functions = diamond_dynamic_usb_functions,
},
};
static struct dynamic_usb_platform_data diamond_dynamic_usb_data = {
.vendor_id = DIAMOND_USB_VENDOR_ID,
.product_id = DIAMOND_USB_PRODUCT_ID,
.manufacturer_name = DIAMOND_USB_VENDOR_STRING,
.product_name = DIAMOND_USB_PRODUCT_STRING,
.serial_number = diamond_serial_number,
.num_products = ARRAY_SIZE(diamond_dynamic_usb_products),
.products = diamond_dynamic_usb_products,
.num_functions = ARRAY_SIZE(diamond_dynamic_usb_functions),
.functions = diamond_dynamic_usb_functions,
};
static struct platform_device diamond_dynamic_usb_device = {
.name = "dynamic_usb",
.id = -1,
.dev = {
.platform_data = &diamond_dynamic_usb_data,
},
};
static const struct dynamic_usb_product j49_dynamic_usb_products[] = {
{
.product_id = J49_USB_PRODUCT_ID,
.num_functions = ARRAY_SIZE(diamond_dynamic_usb_functions),
.functions = diamond_dynamic_usb_functions,
},
};
static struct dynamic_usb_platform_data j49_dynamic_usb_data = {
.vendor_id = J49_USB_VENDOR_ID,
.product_id = J49_USB_PRODUCT_ID,
.manufacturer_name = J49_USB_VENDOR_STRING,
.product_name = J49_USB_PRODUCT_STRING,
.serial_number = diamond_serial_number,
.num_products = ARRAY_SIZE(j49_dynamic_usb_products),
.products = j49_dynamic_usb_products,
.num_functions = ARRAY_SIZE(diamond_dynamic_usb_functions),
.functions = diamond_dynamic_usb_functions,
};
static struct platform_device j49_dynamic_usb_device = {
.name = "dynamic_usb",
.id = -1,
.dev = {
.platform_data = &j49_dynamic_usb_data,
},
};
#endif /* defined(CONFIG_USB_DYNAMIC) */
#if defined(CONFIG_USB_DYNAMIC_MASS_STORAGE)
static struct usb_msc_platform_data diamond_dynamic_usb_msc_data = {
.vendor = DIAMOND_MSC_VENDOR_STRING,
.product = DIAMOND_MSC_PRODUCT_STRING,
.release = DIAMOND_MSC_RELEASE,
.nluns = 1,
};
static struct platform_device diamond_dynamic_usb_msc_device = {
.name = "usb_mass_storage",
.id = -1,
.dev = {
.platform_data = &diamond_dynamic_usb_msc_data,
},
};
#endif /* defined(CONFIG_USB_DYNAMIC_MASS_STORAGE) */
#if defined(CONFIG_OMAP2_DSS)
/*
* Power supplies for digital video interfaces, including the OMAP
* Display Subsystem (DSS) and its Display Serial Interface (DSI)
* block.
*
* On the prototype instantiation of the Diamond board, the TPS65921
* VAUX rail at 2.8V is used to power the Tianma TM025ZDZ01 VCC input.
* This supply is defined elsewhere in this file.
*
* Without these, there will be no functioning LCD display. These
* supplies are largely internal between the TPS65921 and the AM3703;
* whereas, the LCD panel itself it supplied externally to both.
*/
/* VMMC1 */
struct regulator_consumer_supply twl4030_vmmc1_supply = {
.supply = "vmmc",
};
static struct regulator_consumer_supply diamond_vpll2_supplies[] = {
REGULATOR_SUPPLY("vdvi", NULL),
{
.supply = "vdds_dsi",
.dev = &diamond_dss_device.dev,
},
};
static struct regulator_init_data diamond_tps65921_vpll2 = {
.constraints = {
.name = "VDVI",
.min_uV = 1800000,
.max_uV = 1800000,
.apply_uV = true,
.valid_modes_mask = REGULATOR_MODE_NORMAL
| REGULATOR_MODE_STANDBY,
.valid_ops_mask = REGULATOR_CHANGE_MODE
| REGULATOR_CHANGE_STATUS,
},
.num_consumer_supplies = ARRAY_SIZE(diamond_vpll2_supplies),
.consumer_supplies = diamond_vpll2_supplies,
};
#endif /* defined(CONFIG_OMAP2_DSS) */
static struct regulator_consumer_supply diamond_development_vmmc1_supplies[] = {
#if defined(CONFIG_MMC_OMAP_HS)
REGULATOR_SUPPLY("vmmc", "mmci-omap-hs.0"),
#endif /* defined(CONFIG_MMC_OMAP_HS) */
};
static struct regulator_consumer_supply diamond_prototype_vmmc1_supplies[] = {
#if defined(CONFIG_MMC_OMAP_HS)
REGULATOR_SUPPLY("vmmc", "mmci-omap-hs.0"),
#endif /* defined(CONFIG_MMC_OMAP_HS) */
#if defined(CONFIG_INPUT_ADBS_A330)
REGULATOR_SUPPLY(DIAMOND_ADBS_A330_VDDA_SUPPLY, "2-0057"),
#endif /* defined(CONFIG_INPUT_ADBS_A330) */
};
#if !defined(CONFIG_WILINK) && !defined(CONFIG_WILINK_MODULE)
static struct regulator_consumer_supply diamond_vmmc2_supplies[] = {
REGULATOR_SUPPLY("vmmc", "mmci-omap-hs.1")
};
static struct regulator_init_data diamond_vmmc2_data = {
.constraints = {
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.valid_ops_mask = REGULATOR_CHANGE_STATUS,
.always_on = false,
},
.num_consumer_supplies = ARRAY_SIZE(diamond_vmmc2_supplies),
.consumer_supplies = diamond_vmmc2_supplies,
};
static struct fixed_voltage_config diamond_vmmc2_pdata = {
.supply_name = "vmmc2",
.microvolts = 1800000,
.gpio = DIAMOND_GPIO_WIFI_ENABLE,
.startup_delay = 70000, /* 70 ms */
.enable_high = true,
.enabled_at_boot = false,
.init_data = &diamond_vmmc2_data,
};
static struct platform_device diamond_vmmc2_device = {
.name = "reg-fixed-voltage",
.id = -1,
.dev = {
.platform_data = &diamond_vmmc2_pdata,
},
};
#endif /* !defined(CONFIG_WILINK) && !defined(CONFIG_WILINK_MODULE) */
#if defined(CONFIG_TWL4030_MADC)
static struct twl4030_madc_platform_data __initdata diamond_tps65921_madc_data = {
.irq_line = 1
};
#endif
/* VMMC1 for MMC1 pins CMD, CLK, DAT0..DAT3 (20 mA, plus card == max 220 mA) */
struct regulator_init_data vmmc1_data = {
.constraints = {
.min_uV = 1850000,
.max_uV = 3150000,
.valid_modes_mask = REGULATOR_MODE_NORMAL
| REGULATOR_MODE_STANDBY,
.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
| REGULATOR_CHANGE_MODE
| REGULATOR_CHANGE_STATUS,
},
.num_consumer_supplies = 1,
.consumer_supplies = &twl4030_vmmc1_supply
};
static struct twl4030_platform_data __initdata diamond_tps65921_data = {
.irq_base = TWL4030_IRQ_BASE,
.irq_end = TWL4030_IRQ_END,
// platform_data for children goes here
.power = &diamond_tps65921_scripts_data,
.usb = &diamond_tps65921_usb_data,
.gpio = &diamond_tps65921_gpio_data,
.vmmc1 = &vmmc1_data,
#if defined(CONFIG_TWL4030_MADC)
.madc = &diamond_tps65921_madc_data,
#endif
#if defined(CONFIG_OMAP2_DSS)
.vpll2 = &diamond_tps65921_vpll2,
#endif
.vaux2 = &diamond_vaux2
};
/*
* This is identical to diamond except for using j49 scripts data and
* setting the vmmc1 data to NULL (VMMC1 is off for j49).
*/
static struct twl4030_platform_data __initdata j49_tps65921_data = {
.irq_base = TWL4030_IRQ_BASE,
.irq_end = TWL4030_IRQ_END,
/* platform_data for children goes here */
.power = &j49_tps65921_scripts_data,
.usb = &diamond_tps65921_usb_data,
.gpio = &diamond_tps65921_gpio_data,
#if defined(CONFIG_TWL4030_MADC)
.madc = &diamond_tps65921_madc_data,
#endif
#if defined(CONFIG_OMAP2_DSS)
.vpll2 = &diamond_tps65921_vpll2,
#endif
.vaux2 = &diamond_vaux2
};
static struct i2c_board_info __initdata diamond_tps65921_i2c_info[] = {
{
I2C_BOARD_INFO("twl4030", 0x48),
.flags = I2C_CLIENT_WAKE,
.irq = INT_34XX_SYS_NIRQ,
.platform_data = &diamond_tps65921_data,
},
};
static struct i2c_board_info __initdata j49_tps65921_i2c_info[] = {
{
I2C_BOARD_INFO("twl4030", 0x48),
.flags = I2C_CLIENT_WAKE,
.irq = INT_34XX_SYS_NIRQ,
.platform_data = &j49_tps65921_data,
},
};
#if defined(CONFIG_SENSORS_SI1143)
static struct si1143_platform_data diamond_si1143_data = {
.proximity_tx_led1 = 1,
.proximity_tx_led2 = 0,
.proximity_tx_led3 = 0,
};
#endif /* defined(CONFIG_SENSORS_SI1143) */
#if defined(CONFIG_INPUT_ADBS_A330)
static struct adbs_a330_platform_data diamond_adbs_a330_data = {
.vdda_supply = DIAMOND_ADBS_A330_VDDA_SUPPLY,
.vdda_uv = DIAMOND_ADBS_A330_VDDA_UV,
.motion_gpio = DIAMOND_GPIO_OFN_MOTION_L
/*
* We'll fix up both the shutdown and reset GPIO assignments based
* on the model.
*
* We'll also fix up both direction and mode at runtime based on
* the detected model.
*
* Generally, DIRECTION_NEG for form factor enclosures,
* DIRECTION_POS otherwise and DELTA_X for form factor enclosures,
* DELTA_Y otherwise.
*/
};
/*
* No regulator control necessary for j49, OFN is powered from VIO
*/
static struct adbs_a330_platform_data j49_adbs_a330_data = {
.motion_gpio = DIAMOND_GPIO_OFN_MOTION_L
/*
* We'll fix up both the shutdown and reset GPIO assignments based
* on the model.
*
* We'll also fix up both direction and mode at runtime based on
* the detected model.
*
* Generally, DIRECTION_NEG for form factor enclosures,
* DIRECTION_POS otherwise and DELTA_X for form factor enclosures,
* DELTA_Y otherwise.
*/
};
#endif /* defined(CONFIG_INPUT_ADBS_A330) */
static struct i2c_board_info __initdata diamond_development_i2c_2_info[] = {
#if defined(CONFIG_SENSORS_SI1143)
{
I2C_BOARD_INFO("si1143", 0x5A),
.flags = I2C_CLIENT_WAKE,
.irq = DIAMOND_GPIO_PROX_ALS_IRQ,
.platform_data = &diamond_si1143_data,
},
#endif /* defined(CONFIG_SENSORS_SI1143) */
};
static struct i2c_board_info __initdata diamond_prototype_i2c_2_info[] = {
#if defined(CONFIG_INPUT_ADBS_A330)
{
I2C_BOARD_INFO("avago-adbs-a330", 0x57),
.platform_data = &diamond_adbs_a330_data,
}
#endif /* defined(CONFIG_INPUT_ADBS_A330) */
};
static struct i2c_board_info __initdata j49_i2c_2_info[] = {
#if defined(CONFIG_INPUT_ADBS_A330)
{
I2C_BOARD_INFO("avago-adbs-a330", 0x57),
.platform_data = &j49_adbs_a330_data,
}
#endif /* defined(CONFIG_INPUT_ADBS_A330) */
};
#if defined(CONFIG_GENERIC_CMOS_UPDATE) && defined(CONFIG_RTC_LIB)
/**
* update_persistent_clock - set the hardware clock time to system time
* @now: the current system wall clock time.
*
* This routine attempts to access the primary hardware real-time
* clock and, if successful, sets it to the current system wall clock
* time.
*
* This generation (2.6.32) of ARM kernel has an alternative function
* do_set_rtc in linux/arch/arm/kernel/time.c that does something
* similar; however, in a more awkward and non-standard way. So much
* so, that in 2.6.36 kernels, it's gone away entirely.
*
* This more or less matches what is in linux/arch/sparc/kernel/time_64.c
*
* Returns 0 if the real-time clock was successfully set to the system
* wall clock time; otherwise, < 0 on error.
*/
int update_persistent_clock(struct timespec now)
{
const char * name = "rtc0";
struct rtc_device *rtc;
int err = -ENODEV;
rtc = rtc_class_open(name);
if (rtc) {
err = rtc_set_mmss(rtc, now.tv_sec);
rtc_class_close(rtc);
}
return err;
}
#endif /* defined(CONFIG_GENERIC_CMOS_UPDATE) && defined(CONFIG_RTC_LIB) */
static struct omap_board_config_kernel diamond_config[] __initdata = {
};
static void __init diamond_irq_init(void)
{
omap_board_config = diamond_config;
omap_board_config_size = ARRAY_SIZE(diamond_config);
omap2_init_common_infrastructure();
omap2_init_common_devices(k4x51163pi_nt6d_sdrc_params, NULL);
omap_init_irq();
gpmc_init();
}
static struct platform_device *diamond_common_devices[] __initdata = {
&diamond_dss_device,
&diamond_piezo_pwm_device,
#if defined(CONFIG_WILINK) || defined(CONFIG_WILINK_MODULE)
&diamond_wl1271_device,
#endif
&diamond_piezo_device,
&diamond_backplate_device,
#if defined(CONFIG_USB_DYNAMIC_MASS_STORAGE)
&diamond_dynamic_usb_msc_device,
#endif
#if !defined(CONFIG_WILINK) && !defined(CONFIG_WILINK_MODULE)
&diamond_vmmc2_device,
#endif /* !defined(CONFIG_WILINK) && !defined(CONFIG_WILINK_MODULE) */
};
static struct platform_device *diamond_development_devices[] __initdata = {
#if defined(CONFIG_USB_DYNAMIC)
&diamond_dynamic_usb_device,
#endif
#if defined(CONFIG_INPUT_GPIO_ROTARY_ENCODER_LITE)
&diamond_rotary_device,
#endif
&diamond_tps61042_backlight_device,
&diamond_backlight_pwm_device,
&diamond_zigbee_device,
};
static struct platform_device *diamond_prototype_devices[] __initdata = {
#if defined(CONFIG_USB_DYNAMIC)
&diamond_dynamic_usb_device,
#endif
#if defined(CONFIG_SENSORS_TWL4030_MADC)
&diamond_madc_hwmon_device,
#endif
&diamond_tps61042_backlight_device,
&diamond_backlight_pwm_device,
&diamond_zigbee_device,
};
static struct platform_device *diamond_1_6_devices[] __initdata = {
#if defined(CONFIG_USB_DYNAMIC)
&diamond_dynamic_usb_device,
#endif
#if defined(CONFIG_SENSORS_TWL4030_MADC)
&diamond_madc_hwmon_device,
#endif
&diamond_battery_device,
&diamond_tps61042_backlight_device,
&diamond_backlight_pwm_device,
&diamond_zigbee_device,
};
static struct platform_device *display_2_0_devices[] __initdata = {
#if defined(CONFIG_USB_DYNAMIC)
&j49_dynamic_usb_device,
#endif
#if defined(CONFIG_SENSORS_TWL4030_MADC)
&diamond_madc_hwmon_device,
#endif
&diamond_battery_device,
&j49_lm3530_backlight_device,
&j49_zigbee_device,
};
#ifdef CONFIG_OMAP_MUX
/*
* These are listed in schematic order, starting from the first CPU
* block symbol to the second, upper left corner to lower right
* corner.
*
* Do NOT be tempted to refactor these into a set of common mux
* settings and board-specific mux settings as omap3_mux_init does not
* tolerate being called twice and will overwrite previous settings
* with package defaults before applying the second set of
* board-specific settings.
*/
#include "board-diamond-development-mux.c"
#include "board-diamond-prototype-mux.c"
#include "board-diamond-evt-mux.c"
#include "board-diamond-dvt-mux.c"
#include "board-j49-prototype-mux.c"
#include "board-j49-evt-mux.c"
#else
#define diamond_development_mux NULL
#define diamond_prototype_mux NULL
#define diamond_evt_mux NULL
#define diamond_dvt_mux NULL
#define j49_prototype_mux NULL
#define j49_evt_mux NULL
#endif
#if defined(CONFIG_USB_DYNAMIC)
/**
* diamond_serial_number_init - initialize the board serial number used for USB
*
* This routine attempts to decode the board serial number, passed
* from the boot loader via ATAGs, and format it into a
* NULL-terminated C string used by the USB dynamic multi-function
* composite gadget interface.
*
* Successful implementation of this relies on the fact that
* manufacturing is restricting the serial number format to 15 decimal
* digits which we represent as a zero-padded, right-aligned
* hexadecimal number. Were that not the case, the serial number would
* have to be passed as a string on the kernel command line or we'd
* have to have a u-boot environment driver in the kernel.
*/
static void __init diamond_serial_number_init(void)
{
snprintf(diamond_serial_number,
DIAMOND_USB_SERIAL_STRING_SIZE,
"%.07X%.08X",
system_serial_high,
system_serial_low);
}
#else
static inline void diamond_serial_number_init(void) { return; }
#endif /* defined(CONFIG_USB_DYNAMIC) */
static void __init diamond_usb_init(void)
{
diamond_serial_number_init();
// USB 2.0 High-speed device support initialization
usb_musb_init(&musb_board_data);
#if defined(CONFIG_USB_OHCI_HCD) || defined(CONFIG_USB_OHCI_HCD_MODULE)
// USB 2.0 Full-speed host support initialization
diamond_gpio_try_output(DIAMOND_GPIO_INTUSB_SUSPEND, 0, return);
usb_ohci_init(&diamond_ohci_pdata);
#else
diamond_gpio_try_output(DIAMOND_GPIO_INTUSB_SUSPEND, 1, return);
#endif
}
static void __init diamond_backplate_init(const struct nlmodel *model)
{
diamond_backplate_device.dev.platform_data = (void *)((!strcmp(model->family, diamond_family) && \
(model->revision <= 3)) ? 0 : 1);
}
static void __init diamond_clk_init(void)
{
struct clk *sys_clkout1 = NULL;
/* In this architecture, we use the AM3703 as a 19.2 MHz clock
* master and the TPS65921 as a clock slave, fed via the AM3703's
* sys_clkout1 pin.
*
* We need to request the 'sys_clkout1' clock source to at least
* give it a reference count of one (1); otherwise, if the power
* management code has been configured, it'll get unceremoniously
* turned off with a message:
*
* Disabling unused clock "sys_clkout1"
*
* and general system functionality fails thereafter.
*/
sys_clkout1 = clk_get(NULL, "sys_clkout1");
BUG_ON(IS_ERR(sys_clkout1));
clk_enable(sys_clkout1);
}
static void __init diamond_development_mux_init(void)
{
const int flags = OMAP_PACKAGE_CUS;
omap3_mux_init(diamond_development_mux, flags);
}
static void __init diamond_1_4_mux_init(void)
{
const int flags = OMAP_PACKAGE_CUS;
omap3_mux_init(diamond_prototype_mux, flags);
}
static void __init diamond_1_5_mux_init(void)
{
const int flags = OMAP_PACKAGE_CUS;
omap3_mux_init(diamond_prototype_mux, flags);
}
static void __init diamond_1_6_mux_init(void)
{
const int flags = OMAP_PACKAGE_CUS;
omap3_mux_init(diamond_evt_mux, flags);
}
static void __init diamond_1_7_mux_init(void)
{
const int flags = OMAP_PACKAGE_CUS;
omap3_mux_init(diamond_dvt_mux, flags);
}
static void __init display_2_0_mux_init(void)
{
const int flags = OMAP_PACKAGE_CUS;
omap3_mux_init(j49_prototype_mux, flags);
}
static void __init display_2_1_mux_init(void)
{
const int flags = OMAP_PACKAGE_CUS;
omap3_mux_init(j49_evt_mux, flags);
}
static void __init diamond_development_i2c_init(void)
{
omap_register_i2c_bus(1, 2600, diamond_tps65921_i2c_info,
ARRAY_SIZE(diamond_tps65921_i2c_info));
omap_register_i2c_bus(2, 400, diamond_development_i2c_2_info,
ARRAY_SIZE(diamond_development_i2c_2_info));
}
static void __init diamond_1_4_i2c_init(void)
{
#if defined(CONFIG_INPUT_ADBS_A330)
/* Fix-up the shutdown and reset GPIOs as appropriate. */
diamond_adbs_a330_data.shutdown_gpio = DIAMOND_PROTOTYPE_GPIO_OFN_SHUTDOWN;
diamond_adbs_a330_data.reset_gpio = DIAMOND_PROTOTYPE_GPIO_OFN_RESET_L;
/* Fix-up the direction and mode as apppropriate. */
diamond_adbs_a330_data.direction = ADBS_A330_DIRECTION_POS;
diamond_adbs_a330_data.mode = ADBS_A330_DELTA_Y;
#endif /* defined(CONFIG_INPUT_ADBS_A330) */
omap_register_i2c_bus(1, 2600, diamond_tps65921_i2c_info,
ARRAY_SIZE(diamond_tps65921_i2c_info));
omap_register_i2c_bus(2, 400, diamond_prototype_i2c_2_info,
ARRAY_SIZE(diamond_prototype_i2c_2_info));
}
static void __init diamond_1_5_i2c_init(void)
{
/* Fix-up the shutdown and reset GPIOs as appropriate. */
#if defined(CONFIG_INPUT_ADBS_A330)
diamond_adbs_a330_data.shutdown_gpio = DIAMOND_PROTOTYPE_GPIO_OFN_SHUTDOWN;
diamond_adbs_a330_data.reset_gpio = DIAMOND_PROTOTYPE_GPIO_OFN_RESET_L;
/* Fix-up the direction and mode as apppropriate.*/
diamond_adbs_a330_data.direction = ADBS_A330_DIRECTION_NEG;
diamond_adbs_a330_data.mode = ADBS_A330_DELTA_X;
#endif /* defined(CONFIG_INPUT_ADBS_A330) */
omap_register_i2c_bus(1, 2600, diamond_tps65921_i2c_info,
ARRAY_SIZE(diamond_tps65921_i2c_info));
omap_register_i2c_bus(2, 400, diamond_prototype_i2c_2_info,
ARRAY_SIZE(diamond_prototype_i2c_2_info));
}
static void __init diamond_1_6_i2c_init(void)
{
/* Fix-up the shutdown and reset GPIOs as appropriate.*/
#if defined(CONFIG_INPUT_ADBS_A330)
diamond_adbs_a330_data.shutdown_gpio = DIAMOND_EVT_GPIO_OFN_SHUTDOWN;
diamond_adbs_a330_data.reset_gpio = DIAMOND_EVT_GPIO_OFN_RESET_L;
/* Fix-up the direction and mode as apppropriate.*/
diamond_adbs_a330_data.direction = ADBS_A330_DIRECTION_NEG;
diamond_adbs_a330_data.mode = ADBS_A330_DELTA_X;
#endif /* defined(CONFIG_INPUT_ADBS_A330) */
omap_register_i2c_bus(1, 400, diamond_tps65921_i2c_info,
ARRAY_SIZE(diamond_tps65921_i2c_info));
omap_register_i2c_bus(2, 400, diamond_prototype_i2c_2_info,
ARRAY_SIZE(diamond_prototype_i2c_2_info));
}
static void __init display_2_0_i2c_init(void)
{
#if defined(CONFIG_INPUT_ADBS_A330)
/* Fix-up the shutdown and reset GPIOs as appropriate. */
j49_adbs_a330_data.shutdown_gpio = DIAMOND_EVT_GPIO_OFN_SHUTDOWN;
j49_adbs_a330_data.reset_gpio = DIAMOND_EVT_GPIO_OFN_RESET_L;
/* Fix-up the direction and mode as apppropriate. */
j49_adbs_a330_data.direction = ADBS_A330_DIRECTION_POS;
j49_adbs_a330_data.mode = ADBS_A330_DELTA_Y;
#endif
omap_register_i2c_bus(1, 400, j49_tps65921_i2c_info,
ARRAY_SIZE(j49_tps65921_i2c_info));
omap_register_i2c_bus(2, 400, j49_i2c_2_info,
ARRAY_SIZE(j49_i2c_2_info));
omap_register_i2c_bus(3, 400, j49_backlight_i2c_info,
ARRAY_SIZE(j49_backlight_i2c_info));
}
static void __init diamond_1_4_piezo_init(void)
{
diamond_pwm_beeper_data.init = diamond_prototype_piezo_init;
diamond_pwm_beeper_data.exit = diamond_prototype_piezo_exit;
diamond_pwm_beeper_data.notify = diamond_prototype_piezo_notify;
}
static void __init diamond_1_5_piezo_init(void)
{
diamond_1_4_piezo_init();
}
static void __init diamond_development_add_devices(void)
{
platform_add_devices(diamond_common_devices,
ARRAY_SIZE(diamond_common_devices));
platform_add_devices(diamond_development_devices,
ARRAY_SIZE(diamond_development_devices));
}
static void __init diamond_1_4_add_devices(void)
{
platform_add_devices(diamond_common_devices,
ARRAY_SIZE(diamond_common_devices));
platform_add_devices(diamond_prototype_devices,
ARRAY_SIZE(diamond_prototype_devices));
}
static void __init diamond_1_5_add_devices(void)
{
diamond_1_4_add_devices();
}
static void __init diamond_1_6_add_devices(void)
{
platform_add_devices(diamond_common_devices,
ARRAY_SIZE(diamond_common_devices));
platform_add_devices(diamond_1_6_devices,
ARRAY_SIZE(diamond_1_6_devices));
}
/**
* diamond_1_7_add_devices - Add platform devices for model identifier "Diamond-1.7"
*
* Diamond-1.7 has an identical set of devices to Diamond-1.6, so
* simply add those.
*/
static void __init diamond_1_7_add_devices(void)
{
platform_add_devices(diamond_common_devices,
ARRAY_SIZE(diamond_common_devices));
platform_add_devices(diamond_1_6_devices,
ARRAY_SIZE(diamond_1_6_devices));
}
static void __init display_2_0_add_devices(void)
{
platform_add_devices(diamond_common_devices,
ARRAY_SIZE(diamond_common_devices));
platform_add_devices(display_2_0_devices,
ARRAY_SIZE(display_2_0_devices));
}
static void __init diamond_development_spi_init(void)
{
spi_register_board_info(diamond_development_spi_board_info,
ARRAY_SIZE(diamond_development_spi_board_info));
}
static void __init diamond_1_4_spi_init(void)
{
spi_register_board_info(diamond_1_4_spi_board_info,
ARRAY_SIZE(diamond_1_4_spi_board_info));
}
static void __init diamond_1_5_spi_init(void)
{
spi_register_board_info(diamond_1_5_spi_board_info,
ARRAY_SIZE(diamond_1_5_spi_board_info));
}
static void __init diamond_1_7_spi_init(void)
{
spi_register_board_info(diamond_1_7_spi_board_info,
ARRAY_SIZE(diamond_1_7_spi_board_info));
}
static void __init display_2_0_spi_init(void)
{
spi_register_board_info(display_2_0_spi_board_info,
ARRAY_SIZE(display_2_0_spi_board_info));
}
static void __init diamond_serial_init(void)
{
omap_serial_init();
}
static void __init diamond_development_mmc_init(void)
{
omap2_hsmmc_init(diamond_development_tps65921_mmc);
}
static void __init diamond_1_4_mmc_init(void)
{
omap2_hsmmc_init(diamond_prototype_tps65921_mmc);
}
static void __init diamond_1_5_mmc_init(void)
{
diamond_1_4_mmc_init();
}
static void __init diamond_development_display_init(void)
{
omapfb_set_platform_data(&diamond_320_480_omapfb_config);
diamond_display_gpio_init();
diamond_dss_devices[0] = &diamond_development_lcd_device;
diamond_dss_data.default_device = &diamond_development_lcd_device;
}
static void __init diamond_1_4_display_init(void)
{
omapfb_set_platform_data(&diamond_320_480_omapfb_config);
diamond_dss_devices[0] = &diamond_1_4_lcd_device;
diamond_dss_data.default_device = &diamond_1_4_lcd_device;
}
static void __init diamond_1_5_display_init(void)
{
omapfb_set_platform_data(&diamond_320_320_omapfb_config);
diamond_dss_devices[0] = &diamond_1_5_lcd_device;
diamond_dss_data.default_device = &diamond_1_5_lcd_device;
}
static void __init display_2_11_display_init(void)
{
int value;
diamond_gpio_try_input(DIAMOND_GPIO_LCD_ID, goto done);
value = gpio_get_value(DIAMOND_GPIO_LCD_ID);
gpio_free(DIAMOND_GPIO_LCD_ID);
if (value == LCD_ID_SAMSUNG)
{
omapfb_set_platform_data(&diamond_320_320_omapfb_config);
diamond_dss_devices[0] = &diamond_1_5_lcd_device;
diamond_dss_data.default_device = &diamond_1_5_lcd_device;
}
else
{
//renesas display driver
display_2_11_lcd_device.data = &r61529a1_config;
diamond_320_320_omapfb_config.lcd.rotation = 2;
omapfb_set_platform_data(&diamond_320_320_omapfb_config);
diamond_dss_devices[0] = &display_2_11_lcd_device;
diamond_dss_data.default_device = &display_2_11_lcd_device;
}
done:
return;
}
static void __init diamond_development_regulator_init(void)
{
// First, fix-up the number of and pointer to the consumer
// supplies for the VMMC1 PMU regulator rail; the static
// configuration in twl4030-pmic.c is incorrect for this board.
vmmc1_data.num_consumer_supplies = ARRAY_SIZE(diamond_development_vmmc1_supplies);
vmmc1_data.consumer_supplies = diamond_development_vmmc1_supplies;
// Fix up the LCD VPLL2 supply device.
diamond_vpll2_supplies[0].dev = &diamond_development_lcd_device.dev;
// Fix up the VAUX2 supplies as appropriate for this model
diamond_vaux2.num_consumer_supplies = ARRAY_SIZE(diamond_development_vaux2_supplies);
diamond_vaux2.consumer_supplies = diamond_development_vaux2_supplies;
#if !defined(CONFIG_WILINK) && !defined(CONFIG_WILINK_MODULE)
// Fix up the VMMC2 supply device.
diamond_vmmc2_supplies[0].dev = diamond_development_tps65921_mmc[1].dev;
#endif /* !defined(CONFIG_WILINK) && !defined(CONFIG_WILINK_MODULE) */
}
static void __init diamond_prototype_regulator_init(struct device *lcd_dev)
{
// First, fix-up the number of and pointer to the consumer
// supplies for the VMMC1 PMU regulator rail; the static
// configuration in twl4030-pmic.c is incorrect for this board.
vmmc1_data.num_consumer_supplies = ARRAY_SIZE(diamond_prototype_vmmc1_supplies);
vmmc1_data.consumer_supplies = diamond_prototype_vmmc1_supplies;
// Fix up the LCD VPLL2 supply device.
diamond_vpll2_supplies[0].dev = lcd_dev;
// Fix up the LCD VAUX2 supply device.
diamond_prototype_vaux2_supplies[1].dev = lcd_dev;
// Fix up the VAUX2 supplies as appropriate for this model
diamond_vaux2.num_consumer_supplies = ARRAY_SIZE(diamond_prototype_vaux2_supplies);
diamond_vaux2.consumer_supplies = diamond_prototype_vaux2_supplies;
#if !defined(CONFIG_WILINK) && !defined(CONFIG_WILINK_MODULE)
// Fix up the VMMC2 supply device.
diamond_vmmc2_supplies[0].dev = diamond_prototype_tps65921_mmc[0].dev;
#endif /* !defined(CONFIG_WILINK) && !defined(CONFIG_WILINK_MODULE) */
}
static void __init diamond_1_4_regulator_init(void)
{
diamond_prototype_regulator_init(&diamond_1_4_lcd_device.dev);
}
static void __init diamond_1_5_regulator_init(void)
{
diamond_prototype_regulator_init(&diamond_1_5_lcd_device.dev);
}
static void __init display_2_11_regulator_init(void)
{
diamond_prototype_regulator_init(&display_2_11_lcd_device.dev);
}
static void __init diamond_1_4_power_init(void)
{
pm_halt_system = twl4030_poweroff;
}
static void __init diamond_1_6_power_init(void)
{
pm_power_off = diamond_1_6_power_off;
pm_halt_system = diamond_1_6_halt_system;
}
#if defined(CONFIG_WL12XX) || defined(CONFIG_WL12XX_MODULE)
static void __init diamond_wl12xx_init(struct wl12xx_platform_data *data, unsigned int gpio, int clock)
{
int err, irq;
const char *name = "WL127x IRQ";
err = gpio_request(gpio, name);
if (err < 0) {
pr_err("Could not request GPIO %u for %s: %d\n", gpio, name, err);
return;
}
irq = OMAP_GPIO_IRQ(gpio);
if (irq < 0) {
pr_err("Could not assign GPIO %u for %s: %d\n", gpio, name, irq);
return;
}
data->irq = irq;
data->board_ref_clock = clock;
wl12xx_set_platform_data(data);
}
#endif /* defined(CONFIG_WL12XX) || defined(CONFIG_WL12XX_MODULE) */
static void __init diamond_development_net_init(void)
{
diamond_smsc911x_init();
diamond_wlan_init();
#if defined(CONFIG_WL12XX) || defined(CONFIG_WL12XX_MODULE)
diamond_wl12xx_init(&diamond_wl12xx_data, DIAMOND_GPIO_WIFI_IRQ, WL12XX_REFCLOCK_26);
#endif /* defined(CONFIG_WL12XX) || defined(CONFIG_WL12XX_MODULE) */
}
static void __init diamond_1_4_net_init(void)
{
diamond_wlan_init();
#if defined(CONFIG_WL12XX) || defined(CONFIG_WL12XX_MODULE)
diamond_wl12xx_init(&diamond_wl12xx_data, DIAMOND_GPIO_WIFI_IRQ, WL12XX_REFCLOCK_26);
#endif /* defined(CONFIG_WL12XX) || defined(CONFIG_WL12XX_MODULE) */
}
static void __init diamond_1_5_net_init(void)
{
diamond_1_4_net_init();
}
static void __init display_2_0_net_init(void)
{
#if defined(CONFIG_WL12XX) || defined(CONFIG_WL12XX_MODULE)
diamond_wl12xx_init(&diamond_wl12xx_data, DIAMOND_GPIO_WIFI_IRQ, WL12XX_REFCLOCK_26_XTAL);
#endif /* defined(CONFIG_WL12XX) || defined(CONFIG_WL12XX_MODULE) */
}
static void __init diamond_model_init(struct nlmodel *model,
const struct diamond_init_data *didp)
{
if (didp == NULL)
return;
if (didp->regulator_init) {
didp->regulator_init();
}
if (didp->power_init) {
didp->power_init();
}
if (didp->backplate_init) {
didp->backplate_init(model);
}
if (didp->display_init) {
didp->display_init();
}
if (didp->mux_init) {
didp->mux_init();
}
if (didp->i2c_init) {
didp->i2c_init();
}
if (didp->piezo_init) {
didp->piezo_init();
}
if (didp->add_devices) {
didp->add_devices();
}
if (didp->spi_init) {
didp->spi_init();
}
if (didp->serial_init) {
didp->serial_init();
}
if (didp->mmc_init) {
didp->mmc_init();
}
if (didp->usb_init) {
didp->usb_init();
}
if (didp->flash_init) {
didp->flash_init();
}
if (didp->net_init) {
didp->net_init();
}
if (didp->clk_init) {
didp->clk_init();
}
}
const struct diamond_init_data * __init __diamond_init_data(const char *family, int product, int revision)
{
const struct diamond_init_data *data = NULL;
if (family != NULL) {
if ((strcmp(family, diamond_family) != 0) && strcmp(family, j49_family) != 0) {
machine_warn("Unsupported model family '%s'\n", family);
} else {
if (product == diamond_product_default) {
if (revision >= 0 && revision <= 3) {
data = diamond_init_data[DIAMOND_DEVELOPMENT_DATA];
} else if (revision == 4) {
data = diamond_init_data[DIAMOND_1_4_DATA];
} else if (revision == 5) {
data = diamond_init_data[DIAMOND_1_5_DATA];
} else if (revision == 6) {
data = diamond_init_data[DIAMOND_1_6_DATA];
} else if (revision == 7) {
data = diamond_init_data[DIAMOND_1_7_DATA];
} else if (revision == 8) {
data = diamond_init_data[DIAMOND_1_8_DATA];
} else if (revision >= 9) {
data = diamond_init_data[DIAMOND_1_9_DATA];
} else if (revision != NL_MODEL_UNKNOWN) {
machine_warn("Unsupported model revision '%d'\n", revision);
} else {
machine_warn("Unknown model revision.\n");
}
} else if (product == j49_product_default) {
if (revision == 0) {
data = diamond_init_data[DISPLAY_2_0_DATA];
} else if (revision == 1) {
data = diamond_init_data[DISPLAY_2_1_DATA];
} else if (revision == 2) {
data = diamond_init_data[DISPLAY_2_2_DATA];
} else if (revision == 3) {
data = diamond_init_data[DISPLAY_2_3_DATA];
} else if ((revision >= 4) && (revision < 11)) {
data = diamond_init_data[DISPLAY_2_4_DATA];
} else if (revision >= 11) {
data = diamond_init_data[DISPLAY_2_11_DATA];
} else if (revision != NL_MODEL_UNKNOWN) {
machine_warn("Unsupported model revision '%d'\n", revision);
} else {
machine_warn("Unknown model revision.\n");
}
} else if (product != NL_MODEL_UNKNOWN) {
machine_warn("Unsupported model product '%d'\n", product);
} else {
machine_warn("Unknown model product.\n");
}
}
}
return data;
}
/**
* diamond_init - machine-specific initialization
*
* This is the machine-specific initialization function called from
* the .init_machine method of the machine defintion structure.
*
* This attempts to determine the machine model we are running on,
* first from the 'nlmodel=<family>-<product>.<revision>' kernel
* command line argument passed in by the boot loader, second the
* BCD-encoded <product:8><revision:8> also passed in from the boot
* loader and encoded in system_rev and, finally, by simply guessing.
*
*/
static void __init diamond_init(void)
{
int status;
struct nlmodel model;
const char *identifier = NULL;
const struct diamond_init_data *didp = NULL;
const char *family = NULL;
int product = NL_MODEL_UNKNOWN, revision = NL_MODEL_UNKNOWN;
bool initialized;
status = nlmodel_init(&model);
initialized = (status == 0);
if (status != 0) {
machine_warn("Could not initialize model.\n");
} else {
identifier = nlmodel_identifier();
if (identifier == NULL) {
machine_warn("Could not determine the model identifier.\n");
} else {
status = nlmodel_parse(identifier, &model);
if (status != 0) {
machine_warn("Unrecognized model identifer '%s'\n", identifier);
} else {
family = model.family;
product = model.product;
revision = model.revision;
didp = __diamond_init_data(family, product, revision);
}
}
}
/* Assume a Diamond family and fall back and try to BCD-decode
* (8-bits each, integer and fractional components) the product
* and revision from the system revision global as it's possible
* that the boot loader can still pass that via tags but the
* 'nlmodel=...' was missed.
*/
if (didp == NULL) {
machine_warn("Trying fallback model information.\n");
if (family == NULL) {
family = diamond_family;
}
product = (system_rev >> 8) & 0xFF;
revision = (system_rev >> 0) & 0xFF;
/* Treat a BCD-encoded value of 0x0000 the same as unknown (0xFFFF). */
if (!product && !revision) {
product = NL_MODEL_UNKNOWN;
revision = NL_MODEL_UNKNOWN;
}
if (model.product != NL_MODEL_UNKNOWN) {
product = model.product;
}
if (model.revision != NL_MODEL_UNKNOWN) {
revision = model.revision;
}
didp = __diamond_init_data(family, product, revision);
}
/* The fallback did not work, guess. */
if (didp == NULL) {
machine_warn("Guessing model information.\n");
family = diamond_family;
product = diamond_product_default;
revision = diamond_revision_default;
didp = __diamond_init_data(family, product, revision);
BUG_ON(didp == NULL);
}
/* Log what model we decoded, fell back to or guessed. */
if ((family != NULL) && (revision != NL_MODEL_UNKNOWN)) {
if ((didp != NULL) && (didp->name != NULL)) {
machine_info("Nest %s %s, Revision %d\n",
family,
didp->name,
revision);
} else {
machine_info("Nest %s, Revision %d\n",
family,
revision);
}
}
/* Perform the model-specific initialization. */
diamond_model_init(&model, didp);
if (initialized) {
nlmodel_destroy(&model);
}
}
/* This board file will support the following board machine identifiers. */
MACHINE_START(OMAP3EVM, "Nest Diamond")
.boot_params = 0x80000100,
.map_io = omap3_map_io,
.reserve = omap_reserve,
.init_irq = diamond_irq_init,
.init_machine = diamond_init,
.timer = &omap_timer,
MACHINE_END
/* MACH_DIAMOND - http://www.arm.linux.org.uk/developer/machines/list.php?id=3745 */
MACHINE_START(DIAMOND, "Nest Diamond")
.boot_params = 0x80000100,
.map_io = omap3_map_io,
.reserve = omap_reserve,
.init_irq = diamond_irq_init,
.init_machine = diamond_init,
.timer = &omap_timer,
MACHINE_END
/* MACH_J49 - http://www.arm.linux.org.uk/developer/machines/list.php?id=4082 */
MACHINE_START(J49, "Nest J49")
.boot_params = 0x80000100,
.map_io = omap3_map_io,
.reserve = omap_reserve,
.init_irq = diamond_irq_init,
.init_machine = diamond_init,
.timer = &omap_timer,
MACHINE_END