static void __init msm7x2x_init(void)
{
msm_clock_init(msm_clocks_7x27, msm_num_clocks_7x27);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
msm_serial_debug_init(MSM_UART1_PHYS, INT_UART1,
&msm_device_uart1.dev, 1);
#endif
if (cpu_is_msm7x27())
msm7x2x_clock_data.max_axi_khz = 200000;
msm_acpu_clock_init(&msm7x2x_clock_data);
msm_add_pmem_devices();
msm_add_fb_device();
#if !defined(CONFIG_MSM_SERIAL_DEBUGGER)
if (lge_get_uart_mode())
platform_device_register(&msm_device_uart3);
#endif
platform_add_devices(devices, ARRAY_SIZE(devices));
#ifdef CONFIG_ARCH_MSM7X27
msm_add_kgsl_device();
#endif
msm_add_usb_devices();
#ifdef CONFIG_MSM_CAMERA
config_camera_off_gpios(); /* might not be necessary */
#endif
msm_device_i2c_init();
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
if (cpu_is_msm7x27())
msm_pm_set_platform_data(msm7x27_pm_data,
ARRAY_SIZE(msm7x27_pm_data));
else
msm_pm_set_platform_data(msm7x25_pm_data,
ARRAY_SIZE(msm7x25_pm_data));
msm7x27_wlan_init();
#ifdef CONFIG_ANDROID_RAM_CONSOLE
lge_add_ramconsole_devices();
lge_add_ers_devices();
lge_add_panic_handler_devices();
#endif
lge_add_camera_devices();
lge_add_lcd_devices();
lge_add_btpower_devices();
lge_add_mmc_devices();
lge_add_input_devices();
lge_add_misc_devices();
lge_add_pm_devices();
lge_add_gpio_i2c_devices();
create_testmode_status();
create_sw_version_status();
create_smpl_reset_status();
create_qpst_enable_status();
}
static int msm_serial_debug_remove(const char *val, struct kernel_param *kp)
{
int ret;
static int pre_stat = 1;
ret = param_set_bool(val, kp);
if (ret)
return ret;
if (pre_stat == *(int *)kp->arg)
return 0;
pre_stat = *(int *)kp->arg;
if (*(int *)kp->arg) {
msm_serial_debug_init(init_data.base, init_data.irq,
init_data.clk_device, init_data.signal_irq);
printk(KERN_INFO "enable FIQ serial debugger\n");
return 0;
}
#if defined(CONFIG_MSM_SERIAL_DEBUGGER_CONSOLE)
unregister_console(&msm_serial_debug_console);
#endif
free_irq(init_data.signal_irq, 0);
msm_fiq_set_handler(NULL, 0);
msm_fiq_disable(init_data.irq);
msm_fiq_unselect(init_data.irq);
clk_disable(debug_clk);
printk(KERN_INFO "disable FIQ serial debugger\n");
return 0;
}
static void __init htcleo_init(void)
{
printk("htcleo_init()\n");
msm_hw_reset_hook = htcleo_reset;
do_grp_reset();
do_sdc1_reset();
msm_acpu_clock_init(&htcleo_clock_data);
perflock_init(&htcleo_perflock_data);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
msm_serial_debug_init(MSM_UART1_PHYS, INT_UART1,
&msm_device_uart1.dev, 1, MSM_GPIO_TO_INT(139));
#endif
init_dex_comm();
parse_tag_bdaddr();
config_gpio_table(bt_gpio_table, ARRAY_SIZE(bt_gpio_table));
bt_export_bd_address();
htcleo_audio_init();
msm_device_i2c_init();
/* set the gpu power rail to manual mode so clk en/dis will not
* turn off gpu power, and hang it on resume */
htcleo_kgsl_power_rail_mode(0);
htcleo_kgsl_power(false);
mdelay(100);
htcleo_kgsl_power(true);
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
msm_device_uart_dm1.name = "msm_serial_hs"; /* for bcm */
msm_device_uart_dm1.resource[3].end = 6;
platform_add_devices(devices, ARRAY_SIZE(devices));
htcleo_init_panel();
#ifdef CONFIG_USB_ANDROID
htcleo_add_usb_devices();
#endif
i2c_register_board_info(0, base_i2c_devices, ARRAY_SIZE(base_i2c_devices));
htcleo_init_mmc(0);
platform_device_register(&htcleo_timed_gpios);
//#ifdef CONFIG_HTCLEO_BLINK_ON_BOOT
/* Blink the camera LED shortly to show that we're alive! */
htcleo_blink_camera_led();
//#endif // CONFIG_HTCLEO_BLINK_ON_BOOT
}
static void __init heroc_init(void)
{
int rc;
printk(KERN_INFO "heroc_init() revision=%d\n", system_rev);
config_gpios();
// gpio_request(HEROC_GPIO_H2W_POWER, "heroc_gpio_h2w_power");
// gpio_request(HEROC_GPIO_CABLE_IN2, "heroc_gpio_cable_in2");
gpio_request(HEROC_GPIO_AUD_EXTMIC_SEL, "heroc_gpio_aud_extmic_sel");
msm_hw_reset_hook = heroc_reset;
msm_acpu_clock_init(&heroc_clock_data);
perflock_init(&heroc_perflock_data);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
if (!opt_disable_uart3)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1, INT_UART3_RX);
#endif
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
#endif
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
msm_init_pmic_vibrator(3000);
rc = heroc_init_mmc(system_rev);
if (rc)
printk(KERN_CRIT "%s: MMC init failure (%d)\n", __func__, rc);
msm_i2c_gpio_init();
msm_device_i2c.dev.platform_data = &heroc_i2c_device_data;
/* for (rc=0;rc<ARRAY_SIZE(i2c_devices);rc++){
if (!strcmp(i2c_devices[rc].type,AKM8973_I2C_NAME)){
if (!system_rev)
i2c_devices[rc].irq = 0x1E; //XA
else
i2c_devices[rc].irq = 0x1C;
}
}
if(system_rev < 2) {
microp_data.num_pins = ARRAY_SIZE(microp_pins_0);
microp_data.pin_config = microp_pins_0;
} */
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
platform_add_devices(devices, ARRAY_SIZE(devices));
clear_bluetooth_rx_irq_status();
// heroc_init_panel();
}
static void __init msm7x30_init(void)
{
wake_lock_init(&vbus_wake_lock, WAKE_LOCK_SUSPEND, "board-vbus");
#ifdef CONFIG_DEBUG_LL
{
/* HACK: get a fake clock request for uart2 for debug_ll */
struct clk *uart2_clk;
uart2_clk = clk_get(&msm_device_uart2.dev, "uart_clk");
if (IS_ERR(uart2_clk))
uart2_clk = NULL;
else
clk_enable(uart2_clk);
}
#endif
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
msm_serial_debug_init(MSM_UART2_PHYS, INT_UART2,
&msm_device_uart2.dev, 23, MSM_GPIO_TO_INT(51));
#endif
if (machine_is_msm7x30_fluid())
msm7x30_pmic_keypad_pdata.keymap = msm7x30_fluid_pmic_keymap;
else
msm7x30_pmic_keypad_pdata.keymap = msm7x30_surf_pmic_keymap;
msm7x30_ssbi_pmic_init();
msm7x30_i2c_0_init();
msm7x30_spi_init();
/* set the gpu power rail to manual mode so clk en/dis will not
* turn off gpu power, and hang it on resume */
msm7x30_kgsl_power_rail_mode(0);
msm7x30_kgsl_power(true);
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
msm_device_spi.dev.platform_data = &msm7x30_spi_pdata;
platform_add_devices(devices, ARRAY_SIZE(devices));
if (machine_is_msm7x30_fluid()) {
fluid_cyttsp_init();
i2c_register_board_info(0, fluid_i2c_0_board_info,
ARRAY_SIZE(fluid_i2c_0_board_info));
}
i2c_register_board_info(1, surf_i2c_devices,
ARRAY_SIZE(surf_i2c_devices));
if (machine_is_msm7x30_fluid())
fluid_board_props_init();
msm7x30_board_audio_init();
msm_hsusb_set_vbus_state(1);
msm_hsusb_set_vbus_state(0);
msm_hsusb_set_vbus_state(1);
}
static void __init halibut_init(void)
{
if (socinfo_init() < 0)
BUG();
if (machine_is_msm7201a_ffa()) {
smc91x_resources[0].start = 0x98000300;
smc91x_resources[0].end = 0x98000400;
smc91x_resources[1].start = MSM_GPIO_TO_INT(85);
smc91x_resources[1].end = MSM_GPIO_TO_INT(85);
}
/* All 7x01 2.0 based boards are expected to have RAM chips capable
* of 160 MHz. */
if (cpu_is_msm7x01()
&& SOCINFO_VERSION_MAJOR(socinfo_get_version()) == 2)
halibut_clock_data.max_axi_khz = 160000;
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1);
#endif
msm_hsusb_pdata.soc_version = socinfo_get_version();
msm_acpu_clock_init(&halibut_clock_data);
msm_device_hsusb_peripheral.dev.platform_data = &msm_hsusb_pdata,
msm_device_hsusb_host.dev.platform_data = &msm_hsusb_pdata,
platform_add_devices(devices, ARRAY_SIZE(devices));
msm_camera_add_device();
msm_device_i2c_init();
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
#ifdef CONFIG_SURF_FFA_GPIO_KEYPAD
if (machine_is_msm7201a_ffa())
platform_device_register(&keypad_device_7k_ffa);
else
platform_device_register(&keypad_device_surf);
#endif
halibut_init_mmc();
#ifdef CONFIG_USB_FUNCTION
hsusb_gpio_init();
#endif
msm_fb_add_devices();
bt_power_init();
#ifdef CONFIG_USB_ANDROID
msm_hsusb_rpc_connect();
msm_hsusb_set_vbus_state(1) ;
#endif
msm_pm_set_platform_data(msm_pm_data);
}
static void __init halibut_init(void)
{
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1);
#endif
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
msm_acpu_clock_init(&halibut_clock_data);
#ifdef CONFIG_MSM_CAMERA
config_camera_off_gpios(); /* might not be necessary */
#endif
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
platform_add_devices(devices, ARRAY_SIZE(devices));
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
msm_hsusb_set_vbus_state(1);
}
static void __init swordfish_init(void)
{
int rc;
msm_acpu_clock_init(&swordfish_clock_data);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1);
#endif
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
msm_device_touchscreen.dev.platform_data = &swordfish_ts_pdata;
platform_add_devices(devices, ARRAY_SIZE(devices));
msm_hsusb_set_vbus_state(1);
rc = swordfish_init_mmc();
if (rc)
pr_crit("%s: MMC init failure (%d)\n", __func__, rc);
}
static void __init liberty_init(void)
{
int rc;
char *cid = NULL;
struct kobject *properties_kobj;
printk("liberty_init() revision = 0x%X\n", system_rev);
board_get_cid_tag(&cid);
#ifndef CONFIG_SERIAL_MSM_HS_PURE_ANDROID
/* for bcm */
bt_export_bd_address();
#endif
/*
* Setup common MSM GPIOS
*/
config_gpios();
/* We need to set this pin to 0 only once on power-up; we will
* not actually enable the chip until we apply power to it via
* vreg.
*/
gpio_request(LIBERTY_GPIO_LS_EN, "ls_en");
gpio_direction_output(LIBERTY_GPIO_LS_EN, 0);
/* disable power for cm3602 chip */
/*__capella_cm3602_power(0);*/
msm_hw_reset_hook = liberty_reset;
msm_acpu_clock_init(&liberty_clock_data);
perflock_init(&liberty_perflock_data);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
if (!opt_disable_uart3)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1,
MSM_GPIO_TO_INT(LIBERTY_GPIO_UART3_RX));
#endif
msm_add_devices();
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
#ifndef CONFIG_SERIAL_MSM_HS_PURE_ANDROID
msm_device_uart_dm1.name = "msm_serial_hs_bcm"; /* for bcm */
#endif
msm_add_serial_devices(3);
#else
msm_add_serial_devices(0);
#endif
msm_add_serial_devices(2);
#ifdef CONFIG_USB_ANDROID
android_usb_pdata.products[0].product_id =
android_usb_pdata.product_id;
android_usb_pdata.serial_number = board_serialno();
msm_hsusb_pdata.serial_number = board_serialno();
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
platform_device_register(&msm_device_hsusb);
#ifdef CONFIG_USB_ANDROID_RNDIS
platform_device_register(&rndis_device);
#endif
platform_device_register(&usb_mass_storage_device);
platform_device_register(&android_usb_device);
#endif
msm_add_mem_devices(&pmem_setting);
#ifdef CONFIG_MICROP_COMMON
liberty_microp_init();
#endif
rc = liberty_init_mmc(system_rev);
if (rc)
printk(KERN_CRIT "%s: MMC init failure (%d)\n", __func__, rc);
properties_kobj = kobject_create_and_add("board_properties", NULL);
if (properties_kobj)
rc = sysfs_create_group(properties_kobj,
&liberty_properties_attr_group);
if (!properties_kobj || rc)
pr_err("failed to create board_properties\n");
/* probe camera driver */
i2c_register_board_info(0, i2c_camera_devices, ARRAY_SIZE(i2c_camera_devices));
msm_device_i2c_init();
platform_add_devices(devices, ARRAY_SIZE(devices));
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
liberty_init_keypad();
}
static void __init buzzc_init(void)
{
int rc;
struct kobject *properties_kobj;
printk("buzzc_init() revision=%d\n", system_rev);
printk(KERN_INFO "mfg_mode=%d\n", board_mfg_mode());
if (board_mfg_mode() == 1) {
tssc_ts_device_data.cal_err = 25;
printk(KERN_INFO "cal_err=%d\n", tssc_ts_device_data.cal_err);
}
/* for bcm */
bt_export_bd_address();
/*
* Setup common MSM GPIOS
*/
config_gpios();
/* We need to set this pin to 0 only once on power-up; we will
* not actually enable the chip until we apply power to it via
* vreg.
*/
gpio_direction_output(BUZZC_GPIO_LS_EN, 0);
/* disable power for cm3602 chip */
__capella_cm3602_power(0);
msm_hw_reset_hook = buzzc_reset;
msm_acpu_clock_init(&buzzc_clock_data);
perflock_init(&buzzc_perflock_data);
/* adjust GPIOs based on bootloader request */
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
if (!opt_disable_uart3)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1,
MSM_GPIO_TO_INT(BUZZC_GPIO_UART3_RX));
#endif
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
msm_device_uart_dm1.name = "msm_serial_hs_bcm"; /* for bcm */
msm_add_serial_devices(3);
#else
msm_add_serial_devices(0);
#endif
msm_add_serial_devices(2);
msm_add_usb_id_pin_gpio(BUZZC_GPIO_USB_ID_PIN);
msm_add_usb_devices(buzzc_phy_reset, NULL);
msm_add_mem_devices(&pmem_setting);
msm_init_pmic_vibrator();
#ifdef CONFIG_MICROP_COMMON
buzzc_microp_init();
#endif
rc = buzzc_init_mmc(system_rev);
if (rc)
printk(KERN_CRIT "%s: MMC init failure (%d)\n", __func__, rc);
properties_kobj = kobject_create_and_add("board_properties", NULL);
if (properties_kobj)
rc = sysfs_create_group(properties_kobj,
&buzzc_properties_attr_group);
if (!properties_kobj || rc)
pr_err("failed to create board_properties\n");
msm_device_i2c.dev.platform_data = &buzzc_i2c_device_data;
platform_add_devices(devices, ARRAY_SIZE(devices));
i2c_register_board_info(0, i2c_sensor, ARRAY_SIZE(i2c_sensor));
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
i2c_register_board_info(0 , &i2c_microp_devices, 1);
buzzc_init_keypad();
}
static void __init bravo_init(void)
{
int ret;
printk("bravo_init() revision=%d\n", system_rev);
if (is_cdma_version(system_rev))
smd_set_channel_list(smd_cdma_default_channels,
ARRAY_SIZE(smd_cdma_default_channels));
msm_hw_reset_hook = bravo_reset;
if (is_cdma_version(system_rev))
msm_acpu_clock_init(&bravo_cdma_clock_data);
else
msm_acpu_clock_init(&bravo_clock_data);
msm_serial_debug_init(MSM_UART1_PHYS, INT_UART1,
&msm_device_uart1.dev, 1, MSM_GPIO_TO_INT(139));
config_gpio_table(misc_gpio_table, ARRAY_SIZE(misc_gpio_table));
if (is_cdma_version(system_rev)) {
bcm_bt_lpm_pdata.gpio_wake = BRAVO_CDMA_GPIO_BT_WAKE;
bravo_flashlight_data.torch = BRAVO_CDMA_GPIO_FLASHLIGHT_TORCH;
config_gpio_table(bt_gpio_table_rev_CX, ARRAY_SIZE(bt_gpio_table_rev_CX));
} else {
config_gpio_table(bt_gpio_table, ARRAY_SIZE(bt_gpio_table));
}
gpio_request(BRAVO_GPIO_TP_LS_EN, "tp_ls_en");
gpio_direction_output(BRAVO_GPIO_TP_LS_EN, 0);
gpio_request(BRAVO_GPIO_TP_EN, "tp_en");
gpio_direction_output(BRAVO_GPIO_TP_EN, 0);
// gpio_request(BRAVO_GPIO_PROXIMITY_EN, "proximity_en");
// gpio_direction_output(BRAVO_GPIO_PROXIMITY_EN, 1);
gpio_request(BRAVO_GPIO_LS_EN_N, "ls_en");
gpio_request(BRAVO_GPIO_COMPASS_RST_N, "compass_rst");
gpio_direction_output(BRAVO_GPIO_COMPASS_RST_N, 1);
gpio_request(BRAVO_GPIO_COMPASS_INT_N, "compass_int");
gpio_direction_input(BRAVO_GPIO_COMPASS_INT_N);
gpio_request(BRAVO_GPIO_DS2482_SLP_N, "ds2482_slp_n");
/* set the gpu power rail to manual mode so clk en/dis will not
* turn off gpu power, and hang it on resume */
bravo_kgsl_power_rail_mode(0);
bravo_kgsl_power(true);
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
platform_add_devices(devices, ARRAY_SIZE(devices));
i2c_register_board_info(0, base_i2c_devices,
ARRAY_SIZE(base_i2c_devices));
if (is_cdma_version(system_rev)) {
i2c_register_board_info(0, rev_CX_i2c_devices,
ARRAY_SIZE(rev_CX_i2c_devices));
}
ret = bravo_init_mmc(system_rev, debug_uart);
if (ret != 0)
pr_crit("%s: Unable to initialize MMC\n", __func__);
bravo_audio_init();
bravo_headset_init();
platform_device_register(&bravo_timed_gpios);
ds2784_battery_init();
serialno_setup(board_serialno());
}
static void __init hero_init(void)
{
int rc;
printk("hero_init() revision = 0x%X\n", system_rev);
android_usb_pdata.serial_number = board_serialno();
/*
* Setup common MSM GPIOS
*/
config_gpios();
msm_hw_reset_hook = hero_reset;
gpio_request(HERO_TP_LS_EN, "tp_ls_en");
gpio_direction_output(HERO_TP_LS_EN, 0);
gpio_request(HERO_GPIO_EXT_3V_EN, "hero_gpio_ext_3v_en");
gpio_request(HERO_GPIO_CABLE_IN2, "hero_gpio_cable_in2");
gpio_request(HERO_GPIO_AUD_EXTMIC_SEL, "hero_gpio_aud_extmic_sel");
msm_acpu_clock_init(&hero_clock_data);
perflock_init(&hero_perflock_data);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
if (!opt_disable_uart3)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1, INT_UART3_RX);
#endif
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
#endif
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
msm_init_pmic_vibrator(3000);
rc = hero_init_mmc(system_rev);
if (rc)
printk(KERN_CRIT "%s: MMC init failure (%d)\n", __func__, rc);
msm_i2c_gpio_init();
msm_device_i2c.dev.platform_data = &hero_i2c_device_data;
if (system_rev == 0 || system_rev == 1) {
for (rc = 0; rc < ARRAY_SIZE(i2c_devices); rc++) {
if (!strcmp(i2c_devices[rc].type, MICROP_I2C_NAME))
i2c_devices[rc].irq = MSM_GPIO_TO_INT(HERO_GPIO_UP_INT_N_XAXB);
if (!strcmp(i2c_devices[rc].type, AKM8973_I2C_NAME))
i2c_devices[rc].irq = MSM_GPIO_TO_INT(HERO_GPIO_COMPASS_INT_N_XAXB);
}
} else if (system_rev == 2 || system_rev == 3) /*XC and XD*/
hero_h2w.dev.platform_data = &hero_h2w_data_xc;
else /*above XE*/
hero_h2w.dev.platform_data = &hero_h2w_data_xe;
if (hero_engineerid() || system_rev > 2) {
if (system_rev >= 4) {
microp_data.num_pins = ARRAY_SIZE(microp_pins_skuid_3);
microp_data.pin_config = microp_pins_skuid_3;
} else if (system_rev == 3) {
microp_data.num_pins = ARRAY_SIZE(microp_pins_skuid_2);
microp_data.pin_config = microp_pins_skuid_2;
} else {
microp_data.num_pins = ARRAY_SIZE(microp_pins_skuid_1);
microp_data.pin_config = microp_pins_skuid_1;
}
microp_data.cabc_backlight_enable = 1;
}
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
platform_add_devices(devices, ARRAY_SIZE(devices));
hero_init_panel();
}
static void __init desirec_init(void)
{
int rc;
struct kobject *properties_kobj;
printk(KERN_INFO "%s() revision = %d\n", __func__, system_rev);
config_gpios();
if (system_rev > 0) {
/* We need to set this pin to 0 only once on power-up; we will
* not actually enable the chip until we apply power to it via
* vreg.
*/
gpio_direction_output(DESIREC_GPIO_CM3602_EN, 0);
/* disable power for cm3602 chip */
__capella_cm3602_power(0);
}
msm_hw_reset_hook = desirec_reset;
msm_acpu_clock_init(&desirec_clock_data);
perflock_init(&desirec_perflock_data);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
if (!opt_disable_uart3)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1, INT_UART3_RX);
#endif
msm_add_devices();
clear_bluetooth_rx_irq_status();
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
msm_add_serial_devices(MSM_SERIAL_UART1DM);
#else
msm_add_serial_devices(MSM_SERIAL_UART1);
#endif
msm_add_serial_devices(MSM_SERIAL_UART3);
msm_add_usb_devices(desirec_phy_reset, desirec_phy_shutdown);
if (board_mcp_monodie())
msm_add_mem_devices(&pmem_mono_die_setting);
else
msm_add_mem_devices(&pmem_dual_die_setting);
msm_init_pmic_vibrator();
rc = desirec_init_mmc(system_rev);
if (rc)
printk(KERN_CRIT "%s: MMC init failure (%d)\n", __func__, rc);
properties_kobj = kobject_create_and_add("board_properties", NULL);
if (properties_kobj)
rc = sysfs_create_group(properties_kobj,
&desirec_properties_attr_group);
if (!properties_kobj || rc)
pr_err("failed to create board_properties\n");
msm_device_i2c.dev.platform_data = &desirec_i2c_device_data;
if (system_rev > 0) /*Aobve XB*/
platform_add_devices(devices, ARRAY_SIZE(devices));
else /* XA */
platform_add_devices(devices0, ARRAY_SIZE(devices0));
if (system_rev > 0) {
microp_data.ls_power = capella_cm3602_power;
if (system_rev >= 2) {
microp_data.num_pins = ARRAY_SIZE(microp_pins_2);
microp_data.pin_config = microp_pins_2;
}
}
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
/* r porting*/// i2c_register_board_info(0, &i2c_s5k3e2fx, 1);
}
static void __init marvelc_init(void)
{
int rc;
char *cid = NULL;
struct kobject *properties_kobj;
printk("marvelc_init() revision = 0x%X\n", system_rev);
msm_clock_init();
board_get_cid_tag(&cid);
/* for bcm */
bt_export_bd_address();
/*
* Setup common MSM GPIOS
*/
config_gpios();
/* We need to set this pin to 0 only once on power-up; we will
* not actually enable the chip until we apply power to it via
* vreg.
*/
gpio_request(MARVELC_GPIO_LS_EN, "ls_en");
gpio_direction_output(MARVELC_GPIO_LS_EN, 0);
msm_hw_reset_hook = marvelc_reset;
msm_acpu_clock_init(&marvelc_clock_data);
perflock_init(&marvelc_perflock_data);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
if (!opt_disable_uart3)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1,
MSM_GPIO_TO_INT(MARVELC_GPIO_UART3_RX));
#endif
msm_add_devices();
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
msm_device_uart_dm1.name = "msm_serial_hs_bcm"; /* for bcm */
msm_add_serial_devices(3);
#else
msm_add_serial_devices(0);
#endif
msm_add_serial_devices(2);
/*
msm_change_usb_id(0x0bb4, 0x0c10);
*/
#ifdef CONFIG_USB_FUNCTION
msm_add_usb_id_pin_gpio(MARVELC_GPIO_USB_ID_PIN);
msm_add_usb_devices(marvelc_phy_reset, NULL);
#endif
#ifdef CONFIG_USB_ANDROID
android_usb_pdata.products[0].product_id =
android_usb_pdata.product_id;
android_usb_pdata.serial_number = board_serialno();
msm_hsusb_pdata.serial_number = board_serialno();
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
config_marvelc_usb_id_gpios(0);
platform_device_register(&msm_device_hsusb);
platform_device_register(&usb_mass_storage_device);
platform_device_register(&android_usb_device);
#endif
msm_add_mem_devices(&pmem_setting);
#ifdef CONFIG_MICROP_COMMON
marvelc_microp_init();
#endif
rc = marvelc_init_mmc(system_rev);
if (rc)
printk(KERN_CRIT "%s: MMC init failure (%d)\n", __func__, rc);
properties_kobj = kobject_create_and_add("board_properties", NULL);
if (properties_kobj)
rc = sysfs_create_group(properties_kobj,
&marvelc_properties_attr_group);
if (!properties_kobj || rc)
pr_err("failed to create board_properties\n");
printk(KERN_INFO "[HS_BOARD] (%s) system_rev = %d\n", __func__,
system_rev);
if (system_rev >= 1) {
htc_headset_microp.dev.platform_data =
&htc_headset_microp_data_xb;
htc_headset_mgr_data.headset_config_num =
ARRAY_SIZE(htc_headset_mgr_config);
htc_headset_mgr_data.headset_config = htc_headset_mgr_config;
printk(KERN_INFO "[HS_BOARD] (%s) Set MEMS config\n", __func__);
}
/* probe camera driver */
i2c_register_board_info(0, i2c_camera_devices, ARRAY_SIZE(i2c_camera_devices));
/* probe g-sensor driver */
i2c_register_board_info(0, i2c_bma250_devices,
ARRAY_SIZE(i2c_bma250_devices));
msm_device_i2c_init();
platform_add_devices(devices, ARRAY_SIZE(devices));
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
marvelc_init_panel();
marvelc_init_keypad();
marvelc_wifi_init();
msm_init_pmic_vibrator(2800);
}
/* system_rev == higher 16bits of PCBID
XA -> 0000FFFF -> 0x0000
XB -> 0101FFFF -> 0x0101
XC -> 0202FFFF -> 0x0202
*/
static void __init supersonic_init(void)
{
int ret;
struct kobject *properties_kobj;
printk("supersonic_init() revision=%d\n", system_rev);
/* Must set msm_hw_reset_hook before first proc comm */
msm_hw_reset_hook = supersonic_reset;
OJ_BMA_power();
msm_acpu_clock_init(&supersonic_clock_data);
perflock_init(&supersonic_perflock_data);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
msm_device_uart1.dev.platform_data = &msm_uart_debug_pdata;
msm_serial_debug_init(MSM_UART1_PHYS, INT_UART1,
&msm_device_uart1.dev, 1, MSM_GPIO_TO_INT(SUPERSONIC_GPIO_UART1_RX));
#endif
#ifdef CONFIG_ARCH_QSD8X50
bt_export_bd_address();
#endif
/* set the gpu power rail to manual mode so clk en/dis will not
* turn off gpu power, and hang it on resume */
supersonic_kgsl_power_rail_mode(0);
supersonic_kgsl_power(true);
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
msm_device_uart_dm1.name = "msm_serial_hs_bcm"; /* for bcm */
#endif
config_gpio_table(camera_off_gpio_table,
ARRAY_SIZE(camera_off_gpio_table));
/*gpio_direction_output(SUPERSONIC_GPIO_TP_LS_EN, 0);*/
gpio_direction_output(SUPERSONIC_GPIO_TP_EN, 0);
supersonic_audio_init();
supersonic_init_panel();
#ifdef CONFIG_MICROP_COMMON
supersonic_microp_init();
#endif
msm_device_i2c_init();
platform_add_devices(devices, ARRAY_SIZE(devices));
#ifdef CONFIG_USB_ANDROID
if (!opt_usb_h2w_sw)
suc_add_usb_devices();
#endif
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
ret = supersonic_init_mmc(system_rev);
if (ret != 0)
pr_crit("%s: Unable to initialize MMC\n", __func__);
properties_kobj = kobject_create_and_add("board_properties", NULL);
if (properties_kobj)
ret = sysfs_create_group(properties_kobj,
&supersonic_properties_attr_group);
if (!properties_kobj || ret)
pr_err("failed to create board_properties\n");
msm_init_pmic_vibrator(3000);
}
/* system_rev == higher 16bits of PCBID
XA -> 0000FFFF -> 0x0000
XB -> 0101FFFF -> 0x0101
XC -> 0202FFFF -> 0x0202
*/
static void __init supersonic_init(void)
{
int ret;
struct kobject *properties_kobj;
printk("supersonic_init() revision=%d\n", system_rev);
android_usb_pdata.serial_number = board_serialno();
msm_hw_reset_hook = supersonic_reset;
OJ_BMA_power();
msm_acpu_clock_init(&supersonic_clock_data);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
msm_serial_debug_init(MSM_UART1_PHYS, INT_UART1,
&msm_device_uart1.dev, 1, MSM_GPIO_TO_INT(SUPERSONIC_GPIO_UART1_RX));
#endif
#ifdef CONFIG_ARCH_QSD8X50
bt_export_bd_address();
#endif
/* set the gpu power rail to manual mode so clk en/dis will not
* turn off gpu power, and hang it on resume */
supersonic_kgsl_power_rail_mode(0);
supersonic_kgsl_power(true);
#ifdef CONFIG_SPI_QSD
msm_device_spi.dev.platform_data = &supersonic_spi_pdata;
#endif
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
config_gpio_table(usb_phy_3v3_table, ARRAY_SIZE(usb_phy_3v3_table));
config_gpio_table(camera_off_gpio_table,
ARRAY_SIZE(camera_off_gpio_table));
gpio_request(SUPERSONIC_GPIO_TP_EN, "tp_en");
gpio_direction_output(SUPERSONIC_GPIO_TP_EN, 0);
supersonic_audio_init();
supersonic_init_panel();
#ifdef CONFIG_MICROP_COMMON
supersonic_microp_init();
#endif
platform_add_devices(devices, ARRAY_SIZE(devices));
if (!opt_usb_h2w_sw) {
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
config_supersonic_usb_id_gpios(0);
}
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
ret = supersonic_init_mmc(system_rev);
if (ret != 0)
pr_crit("%s: Unable to initialize MMC\n", __func__);
properties_kobj = kobject_create_and_add("board_properties", NULL);
if (properties_kobj)
ret = sysfs_create_group(properties_kobj,
&supersonic_properties_attr_group);
if (!properties_kobj || ret)
pr_err("failed to create board_properties\n");
msm_init_pmic_vibrator();
}
static void __init htcleo_init(void)
{
#ifdef CONFIG_HTCLEO_BLINK_AT_BOOT
volatile unsigned *bank6_in, *bank6_out;
#endif
printk("htcleo_init()\n");
msm_hw_reset_hook = htcleo_reset;
#ifdef CONFIG_PERFLOCK
perflock_init(&htcleo_perflock_data);
#endif
msm_serial_debug_init(MSM_UART1_PHYS, INT_UART1,
&msm_device_uart1.dev, 1, MSM_GPIO_TO_INT(139));
// config_gpio_table(misc_gpio_table, ARRAY_SIZE(misc_gpio_table));
config_gpio_table(bt_gpio_table, ARRAY_SIZE(bt_gpio_table));
gpio_request(HTCLEO_GPIO_TP_LS_EN, "tp_ls_en");
gpio_direction_output(HTCLEO_GPIO_TP_LS_EN, 0);
gpio_request(HTCLEO_GPIO_TP_EN, "tp_en");
gpio_direction_output(HTCLEO_GPIO_TP_EN, 0);
// gpio_request(HTCLEO_GPIO_PROXIMITY_EN, "proximity_en");
// gpio_direction_output(HTCLEO_GPIO_PROXIMITY_EN, 1);
gpio_request(HTCLEO_GPIO_LS_EN_N, "ls_en");
gpio_request(HTCLEO_GPIO_COMPASS_RST_N, "compass_rst");
gpio_direction_output(HTCLEO_GPIO_COMPASS_RST_N, 1);
gpio_request(HTCLEO_GPIO_COMPASS_INT_N, "compass_int");
gpio_direction_input(HTCLEO_GPIO_COMPASS_INT_N);
gpio_request(HTCLEO_GPIO_DS2482_SLP_N, "ds2482_slp_n");
/* set the gpu power rail to manual mode so clk en/dis will not
* turn off gpu power, and hang it on resume */
htcleo_kgsl_power_rail_mode(0);
htcleo_kgsl_power(true);
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
platform_add_devices(devices, ARRAY_SIZE(devices));
i2c_register_board_info(0, base_i2c_devices,
ARRAY_SIZE(base_i2c_devices));
if (htcleo_init_mmc(system_rev, debug_uart) != 0)
pr_crit("%s: Unable to initialize MMC\n", __func__);
htcleo_audio_init();
htcleo_headset_init();
platform_device_register(&htcleo_timed_gpios);
ds2784_battery_init();
msm_acpu_clock_init(&htcleo_clock_data);
//} what's this??
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
msm_device_uart_dm1.name = "msm_serial_hs"; /* for bcm */
msm_device_uart_dm1.resource[3].end = 6;
#endif
config_gpio_table(bt_gpio_table, ARRAY_SIZE(bt_gpio_table));
// bt_export_bd_address();
htcleo_audio_init();
// msm_device_i2c_init();
/* set the gpu power rail to manual mode so clk en/dis will not
* turn off gpu power, and hang it on resume */
htcleo_kgsl_power_rail_mode(0);
htcleo_kgsl_power(false);
mdelay(100);
htcleo_kgsl_power(true);
platform_add_devices(devices, ARRAY_SIZE(devices));
htcleo_init_panel();
i2c_register_board_info(0, base_i2c_devices, ARRAY_SIZE(base_i2c_devices));
#ifdef CONFIG_USB_ANDROID
// htcleo_add_usb_devices();
#endif
// htcleo_init_mmc(0);
platform_device_register(&htcleo_timed_gpios);
/* Blink the camera LED shortly to show that we're alive! */
#ifdef CONFIG_HTCLEO_BLINK_AT_BOOT
bank6_in = (unsigned int*)(MSM_GPIO1_BASE + 0x0864);
bank6_out = (unsigned int*)(MSM_GPIO1_BASE + 0x0814);
*bank6_out = *bank6_in ^ 0x200000;
mdelay(50);
*bank6_out = *bank6_in | 0x200000;
mdelay(200);
#endif
}
static void __init incrediblec_init(void)
{
int ret;
struct kobject *properties_kobj;
printk("incrediblec_init() revision=%d, engineerid=%d\n", system_rev, engineerid);
msm_hw_reset_hook = incrediblec_reset;
if (0 == engineerid || 0xF == engineerid) {
mdp_pmem_pdata.start = MSM_PMEM_MDP_XA_BASE;
android_pmem_adsp_pdata.start = MSM_PMEM_ADSP_XA_BASE;
} else if (engineerid >= 3) {
mdp_pmem_pdata.start = MSM_PMEM_MDP_BASE + MSM_MEM_128MB_OFFSET;
android_pmem_adsp_pdata.start = MSM_PMEM_ADSP_BASE + MSM_MEM_128MB_OFFSET;
}
incrediblec_board_serialno_setup(board_serialno());
OJ_BMA_power();
msm_acpu_clock_init(&incrediblec_clock_data);
perflock_init(&incrediblec_perflock_data);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
msm_serial_debug_init(MSM_UART1_PHYS, INT_UART1,
&msm_device_uart1.dev, 1, INT_UART1_RX);
#endif
bcm_bt_lpm_pdata.gpio_wake = INCREDIBLEC_GPIO_BT_CHIP_WAKE;
config_gpio_table(bt_gpio_table_rev_CX, ARRAY_SIZE(bt_gpio_table_rev_CX));
#ifdef CONFIG_SPI_QSD
msm_device_spi.dev.platform_data = &incrediblec_spi_pdata;
#endif
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
msm_device_uart_dm1.name = "msm_serial_hs"; /* for bcm */
#endif
incrediblec_config_uart_gpios();
config_gpio_table(usb_phy_3v3_table, ARRAY_SIZE(usb_phy_3v3_table));
config_gpio_table(camera_off_gpio_table,
ARRAY_SIZE(camera_off_gpio_table));
/*gpio_direction_output(INCREDIBLEC_GPIO_TP_LS_EN, 0);*/
gpio_direction_output(INCREDIBLEC_GPIO_TP_EN, 0);
incrediblec_audio_init();
#ifdef CONFIG_MICROP_COMMON
incrediblec_microp_init();
#endif
if (system_rev >= 2) {
microp_data.num_functions = ARRAY_SIZE(microp_functions_1);
microp_data.microp_function = microp_functions_1;
}
platform_add_devices(devices, ARRAY_SIZE(devices));
platform_add_devices(msm_footswitch_devices,
msm_num_footswitch_devices);
if (!opt_usb_h2w_sw) {
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
}
if (system_rev > 2) {
incrediblec_atmel_ts_data[0].config_T9[7] = 33;
incrediblec_atmel_ts_data[0].object_crc[0] = 0x2E;
incrediblec_atmel_ts_data[0].object_crc[1] = 0x80;
incrediblec_atmel_ts_data[0].object_crc[2] = 0xE0;
}
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
ret = incrediblec_init_mmc(system_rev);
if (ret != 0)
pr_crit("%s: Unable to initialize MMC\n", __func__);
properties_kobj = kobject_create_and_add("board_properties", NULL);
if (properties_kobj)
ret = sysfs_create_group(properties_kobj,
&incrediblec_properties_attr_group);
if (!properties_kobj || ret)
pr_err("failed to create board_properties\n");
msm_init_pmic_vibrator();
}
static void __init chacha_init(void)
{
int rc;
char *cid = NULL;
char *qwerty_color = NULL;
struct kobject *properties_kobj;
printk("chacha_init() revision = 0x%X\n", system_rev);
msm_clock_init();
board_get_cid_tag(&cid);
board_get_qwerty_color_tag(&qwerty_color);
if (qwerty_color && strcmp(qwerty_color, "white") == 0) {
cm3628_pdata.levels[2] = 24;
cm3628_pdata.levels[3] = 79;
pr_info("[LS][CM3628] Update white table\n");
} else
pr_info("[LS][CM3628] Update %s table\n", qwerty_color);
/* for bcm */
bt_export_bd_address();
/*
* Setup common MSM GPIOS
*/
config_gpios();
/* We need to set this pin to 0 only once on power-up; we will
* not actually enable the chip until we apply power to it via
* vreg.
*/
gpio_request(CHACHA_GPIO_LS_EN, "ls_en");
gpio_direction_output(CHACHA_GPIO_LS_EN, 0);
msm_hw_reset_hook = chacha_reset;
if (socinfo_init() < 0)
BUG();
if ((SOCINFO_VERSION_MAJOR(socinfo_get_version()) > 1)
|| ((SOCINFO_VERSION_MAJOR(socinfo_get_version()) == 1)
&& (SOCINFO_VERSION_MINOR(socinfo_get_version()) >= 3)))
{
msm_acpu_clock_init(&chacha_turbo_clock_data);
perflock_init(&chacha_turbo_perflock_data);
}else{
msm_acpu_clock_init(&chacha_clock_data);
perflock_init(&chacha_perflock_data);
}
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
if (!opt_disable_uart3)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1,
MSM_GPIO_TO_INT(CHACHA_GPIO_UART3_RX));
#endif
msm_add_devices();
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
msm_device_uart_dm1.name = "msm_serial_hs_bcm"; /* for bcm */
msm_add_serial_devices(3);
#else
msm_add_serial_devices(0);
#endif
msm_add_serial_devices(2);
/*
msm_change_usb_id(0x0bb4, 0x0c10);
*/
#ifdef CONFIG_USB_FUNCTION
msm_add_usb_id_pin_gpio(CHACHA_GPIO_USB_ID_PIN);
msm_add_usb_devices(chacha_phy_reset, NULL);
#endif
#ifdef CONFIG_USB_ANDROID
android_usb_pdata.products[0].product_id =
android_usb_pdata.product_id;
android_usb_pdata.serial_number = board_serialno();
msm_hsusb_pdata.serial_number = board_serialno();
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
config_chacha_usb_id_gpios(0);
platform_device_register(&msm_device_hsusb);
platform_device_register(&usb_mass_storage_device);
platform_device_register(&android_usb_device);
#endif
msm_add_mem_devices(&pmem_setting);
#ifdef CONFIG_MICROP_COMMON
chacha_microp_init();
#endif
rc = chacha_init_mmc(system_rev);
if (rc)
printk(KERN_CRIT "%s: MMC init failure (%d)\n", __func__, rc);
properties_kobj = kobject_create_and_add("board_properties", NULL);
if (properties_kobj)
rc = sysfs_create_group(properties_kobj,
&chacha_properties_attr_group);
if (!properties_kobj || rc)
pr_err("failed to create board_properties\n");
/* probe camera driver */
i2c_register_board_info(0, i2c_camera_devices, ARRAY_SIZE(i2c_camera_devices));
printk(KERN_INFO "[HS_BOARD] (%s) system_rev = %d\n", __func__,
system_rev);
if (system_rev >= 2) {
htc_headset_microp.dev.platform_data = &htc_headset_microp_data_xc;
htc_headset_mgr_data.headset_config_num =
ARRAY_SIZE(htc_headset_mgr_config);
htc_headset_mgr_data.headset_config = htc_headset_mgr_config;
printk(KERN_INFO "[HS_BOARD] (%s) Set MEMS config\n", __func__);
}
msm_device_i2c_init();
platform_add_devices(devices, ARRAY_SIZE(devices));
if (system_rev == 0)
i2c_register_board_info(0, i2c_devices_XA,
ARRAY_SIZE(i2c_devices_XA));
else
i2c_register_board_info(0, i2c_devices_XB,
ARRAY_SIZE(i2c_devices_XB));
chacha_init_panel();
chacha_init_keypad();
chacha_wifi_init();
msm_init_pmic_vibrator(3100);
}
static void __init latte_init(void)
{
int rc;
char *cid = NULL;
printk("latte_init() revision = 0x%X\n", system_rev);
board_get_cid_tag(&cid);
/*
* Setup common MSM GPIOS
*/
config_gpios();
/* We need to set this pin to 0 only once on power-up; we will
* not actually enable the chip until we apply power to it via
* vreg.
*/
gpio_direction_output(LATTE_GPIO_LS_EN, 0);
/* disable power for cm3602 chip */
__capella_cm3602_power(0);
msm_hw_reset_hook = latte_reset;
msm_acpu_clock_init(&latte_clock_data);
perflock_init(&latte_perflock_data);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
if (!opt_disable_uart3)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1,
MSM_GPIO_TO_INT(LATTE_GPIO_UART3_RX));
#endif
msm_add_devices();
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
msm_add_serial_devices(3);
#else
msm_add_serial_devices(0);
#endif
msm_add_serial_devices(2);
/*
msm_change_usb_id(0x0bb4, 0x0c10);
*/
msm_add_usb_id_pin_gpio(LATTE_GPIO_USB_ID_PIN);
msm_register_usb_phy_init_seq(espresso_phy_init_seq);
msm_hsusb_set_product(espresso_usb_products,
ARRAY_SIZE(espresso_usb_products));
msm_add_usb_devices(latte_phy_reset, latte_phy_shutdown);
msm_add_mem_devices(&pmem_setting);
msm_init_pmic_vibrator();
#ifdef CONFIG_MICROP_COMMON
latte_microp_init();
#endif
latte_init_h2w_power_gpio();
rc = latte_init_mmc(system_rev);
if (rc)
printk(KERN_CRIT "%s: MMC init failure (%d)\n", __func__, rc);
/* register flashlight at new-XA above */
platform_device_register(&latte_flashlight_device);
/* probe camera driver */
i2c_register_board_info(0, i2c_camera_devices, ARRAY_SIZE(i2c_camera_devices));
msm_device_i2c.dev.platform_data = &latte_i2c_device_data;
platform_add_devices(devices, ARRAY_SIZE(devices));
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
latte_init_keypad();
}
static void __init latte_init(void)
{
int rc;
char *cid = NULL;
printk("latte_init() revision = 0x%X\n", system_rev);
board_get_cid_tag(&cid);
/*
* Setup common MSM GPIOS
*/
config_gpios();
/* We need to set this pin to 0 only once on power-up; we will
* not actually enable the chip until we apply power to it via
* vreg.
*/
gpio_request(LATTE_GPIO_LS_EN, "ls_en");
gpio_direction_output(LATTE_GPIO_LS_EN, 0);
/* disable power for cm3602 chip */
/*__capella_cm3602_power(0);*/
msm_hw_reset_hook = latte_reset;
msm_acpu_clock_init(&latte_clock_data);
perflock_init(&latte_perflock_data);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
if (!opt_disable_uart3)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1,
MSM_GPIO_TO_INT(LATTE_GPIO_UART3_RX));
#endif
msm_add_devices();
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
#ifndef CONFIG_SERIAL_MSM_HS_PURE_ANDROID
msm_device_uart_dm1.name = "msm_serial_hs_ti"; /* for ti */
#endif
msm_add_serial_devices(3);
#else
msm_add_serial_devices(0);
#endif
msm_add_serial_devices(2);
#ifdef CONFIG_USB_FUNCTION
msm_register_usb_phy_init_seq(latte_phy_init_seq);
msm_add_usb_id_pin_gpio(LATTE_GPIO_USB_ID_PIN);
msm_add_usb_devices(latte_phy_reset, NULL);
#endif
#ifdef CONFIG_USB_ANDROID
android_usb_pdata.products[0].product_id =
android_usb_pdata.product_id;
android_usb_pdata.serial_number = board_serialno();
msm_hsusb_pdata.serial_number = board_serialno();
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
#ifdef CONFIG_USB_ANDROID_RNDIS
platform_device_register(&rndis_device);
#endif
platform_device_register(&msm_device_hsusb);
platform_device_register(&usb_mass_storage_device);
platform_device_register(&android_usb_device);
#endif
msm_add_mem_devices(&pmem_setting);
msm_init_pmic_vibrator();
#ifdef CONFIG_MICROP_COMMON
latte_microp_init();
#endif
rc = latte_init_mmc(system_rev);
if (rc)
printk(KERN_CRIT "%s: MMC init failure (%d)\n", __func__, rc);
/* register flashlight at new-XA above */
platform_device_register(&latte_flashlight_device);
/* probe camera driver */
i2c_register_board_info(0, i2c_camera_devices, ARRAY_SIZE(i2c_camera_devices));
msm_device_i2c_init();
platform_add_devices(devices, ARRAY_SIZE(devices));
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
latte_init_keypad();
}
static void __init msm7x2x_init(void)
{
if (socinfo_init() < 0)
BUG();
#ifdef CONFIG_HUAWEI_CAMERA
sensor_vreg_disable(sensor_vreg_array,ARRAY_SIZE(sensor_vreg_array));
#endif
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1);
#endif
/*delete*/
msm_acpu_clock_init(&msm7x2x_clock_data);
msm_hsusb_pdata.swfi_latency =
msm7x25_pm_data
[MSM_PM_SLEEP_MODE_RAMP_DOWN_AND_WAIT_FOR_INTERRUPT].latency;
if(machine_is_msm7x25_u8110()) {
msm_device_hsusb_peripheral.dev.platform_data = &msm_hsusb_tmo_pdata;
} else {
msm_device_hsusb_peripheral.dev.platform_data = &msm_hsusb_pdata;
}
if(machine_is_msm7x25_u8110()) {
mass_storage_device.dev.platform_data = &usb_mass_storage_tmo_pdata;
}
platform_add_devices(devices, ARRAY_SIZE(devices));
#ifdef CONFIG_MSM_CAMERA
config_camera_off_gpios(); /* might not be necessary */
#endif
msm_device_i2c_init();
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
#ifdef CONFIG_SURF_FFA_GPIO_KEYPAD
if (machine_is_msm7x25_ffa() || machine_is_msm7x27_ffa())
platform_device_register(&keypad_device_7k_ffa);
else
platform_device_register(&keypad_device_surf);
#endif
#ifdef CONFIG_HUAWEI_GPIO_KEYPAD
if (machine_is_msm7x25_c8600())
platform_device_register(&keypad_device_c8600);
else if (machine_is_msm7x25_u8110()) //machine_is_msm7x25_u8100()
platform_device_register(&keypad_device_u8100);
else if (machine_is_msm7x25_u7610())
platform_device_register(&keypad_device_u7610);
else
platform_device_register(&keypad_device_c8600); //default use c6800 keypad
#endif
lcdc_gpio_init();
#ifdef CONFIG_HUAWEI_JOGBALL
//config_jogball_gpios();
//init_jogball();
if (machine_is_msm7x25_c8600())
platform_device_register(&jogball_device);
#endif
msm_fb_add_devices();
msm7x2x_init_mmc();
bt_power_init();
msm_pm_set_platform_data(msm7x25_pm_data);
#ifdef CONFIG_HUAWEI_MSM_VIBRATOR
msm_init_pmic_vibrator();
#endif
}
static void __init msm7x27_init(void)
{
if (socinfo_init() < 0)
BUG();
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1);
#endif
if (machine_is_msm7x27_ffa()) {
smc91x_resources[0].start = 0x98000300;
smc91x_resources[0].end = 0x980003ff;
smc91x_resources[1].start = MSM_GPIO_TO_INT(85);
smc91x_resources[1].end = MSM_GPIO_TO_INT(85);
if (gpio_tlmm_config(GPIO_CFG(85, 0,
GPIO_INPUT,
GPIO_PULL_DOWN,
GPIO_2MA),
GPIO_ENABLE)) {
printk(KERN_ERR
"%s: Err: Config GPIO-85 INT\n",
__func__);
}
msm7x27_clock_data.max_axi_khz = 160000;
}
if (cpu_is_msm7x27())
msm7x27_clock_data.max_axi_khz = 200000;
msm_acpu_clock_init(&msm7x27_clock_data);
/* This value has been set to 160000 for power savings. */
/* OEMs may modify the value at their discretion for performance */
/* The appropriate maximum replacement for 160000 is: */
/* clk_get_max_axi_khz() */
kgsl_pdata.max_axi_freq = 160000;
msm_hsusb_pdata.swfi_latency =
msm7x27_pm_data
[MSM_PM_SLEEP_MODE_RAMP_DOWN_AND_WAIT_FOR_INTERRUPT].latency;
msm_device_hsusb_peripheral.dev.platform_data = &msm_hsusb_pdata;
msm_device_otg.dev.platform_data = &msm_otg_pdata;
msm_device_gadget_peripheral.dev.platform_data = &msm_gadget_pdata;
msm_device_hsusb_host.dev.platform_data = &msm_hsusb_pdata;
platform_add_devices(devices, ARRAY_SIZE(devices));
#ifdef CONFIG_MSM_CAMERA
config_camera_off_gpios(); /* might not be necessary */
#endif
msm_device_i2c_init();
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
#ifdef CONFIG_SURF_FFA_GPIO_KEYPAD
if (machine_is_msm7x27_ffa())
platform_device_register(&keypad_device_7k_ffa);
else
platform_device_register(&keypad_device_surf);
#endif
lcdc_gordon_gpio_init();
msm_fb_add_devices();
msm7x27_init_mmc();
bt_power_init();
if (cpu_is_msm7x27())
msm_pm_set_platform_data(msm7x27_pm_data);
else
msm_pm_set_platform_data(msm7x27_pm_data);
}
static void __init incrediblec_init(void)
{
int ret;
struct kobject *properties_kobj;
printk("incrediblec_init() revision=%d, engineerid=%d\n", system_rev, engineerid);
msm_hw_reset_hook = incrediblec_reset;
if (0 == engineerid || 0xF == engineerid) {
mdp_pmem_pdata.start = MSM_PMEM_MDP_XA_BASE;
android_pmem_adsp_pdata.start = MSM_PMEM_ADSP_XA_BASE;
msm_kgsl_resources[1].start = MSM_GPU_MEM_XA_BASE;
msm_kgsl_resources[1].end = MSM_GPU_MEM_XA_BASE + MSM_GPU_MEM_SIZE - 1;
} else if (engineerid >= 3) {
mdp_pmem_pdata.start = MSM_PMEM_MDP_BASE + MSM_MEM_128MB_OFFSET;
android_pmem_adsp_pdata.start = MSM_PMEM_ADSP_BASE + MSM_MEM_128MB_OFFSET;
msm_kgsl_resources[1].start = MSM_GPU_MEM_BASE;
msm_kgsl_resources[1].end = msm_kgsl_resources[1].start + MSM_GPU_MEM_SIZE - 1;
}
OJ_BMA_power();
msm_acpu_clock_init(&incrediblec_clock_data);
perflock_init(&incrediblec_perflock_data);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
msm_serial_debug_init(MSM_UART1_PHYS, INT_UART1,
&msm_device_uart1.dev, 1, INT_UART1_RX);
#endif
#ifdef CONFIG_ARCH_QSD8X50
bt_export_bd_address();
#endif
/* set the gpu power rail to manual mode so clk en/dis will not
* turn off gpu power, and hang it on resume */
incrediblec_kgsl_power_rail_mode(0);
incrediblec_kgsl_power(true);
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
msm_device_uart_dm1.name = "msm_serial_hs"; /* for bcm */
#endif
incrediblec_config_uart_gpios();
config_gpio_table(camera_off_gpio_table,
ARRAY_SIZE(camera_off_gpio_table));
/*gpio_direction_output(INCREDIBLEC_GPIO_TP_LS_EN, 0);*/
gpio_direction_output(INCREDIBLEC_GPIO_TP_EN, 0);
incrediblec_audio_init();
msm_device_i2c_init();
#ifdef CONFIG_MICROP_COMMON
incrediblec_microp_init();
#endif
#ifdef CONFIG_USB_ANDROID
inc_add_usb_devices();
#endif
if (system_rev >= 2) {
microp_data.num_functions = ARRAY_SIZE(microp_functions_1);
microp_data.microp_function = microp_functions_1;
}
platform_add_devices(devices, ARRAY_SIZE(devices));
incrediblec_init_panel();
if (system_rev > 2) {
incrediblec_atmel_ts_data[0].config_T9[7] = 33;
incrediblec_atmel_ts_data[0].object_crc[0] = 0x2E;
incrediblec_atmel_ts_data[0].object_crc[1] = 0x80;
incrediblec_atmel_ts_data[0].object_crc[2] = 0xE0;
}
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
ret = incrediblec_init_mmc(system_rev);
if (ret != 0)
pr_crit("%s: Unable to initialize MMC\n", __func__);
properties_kobj = kobject_create_and_add("board_properties", NULL);
if (properties_kobj)
ret = sysfs_create_group(properties_kobj,
&incrediblec_properties_attr_group);
if (!properties_kobj || ret)
pr_err("failed to create board_properties\n");
msm_init_pmic_vibrator();
}
static void __init msm7x2x_init(void)
{
if (socinfo_init() < 0)
BUG();
msm_clock_init(msm_clocks_7x27, msm_num_clocks_7x27);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1);
#endif
if (cpu_is_msm7x27())
msm7x2x_clock_data.max_axi_khz = 200000;
msm_acpu_clock_init(&msm7x2x_clock_data);
msm_add_pmem_devices();
msm_add_fb_device();
#if !defined(CONFIG_MSM_SERIAL_DEBUGGER)
if (lge_get_uart_mode())
platform_device_register(&msm_device_uart3);
#endif
platform_add_devices(devices, ARRAY_SIZE(devices));
#ifdef CONFIG_ARCH_MSM7X27
msm_add_kgsl_device();
#endif
msm_add_usb_devices();
#ifdef CONFIG_MSM_CAMERA
config_camera_off_gpios(); /* might not be necessary */
#endif
msm_device_i2c_init();
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
if (cpu_is_msm7x27())
msm_pm_set_platform_data(msm7x27_pm_data,
ARRAY_SIZE(msm7x27_pm_data));
else
msm_pm_set_platform_data(msm7x25_pm_data,
ARRAY_SIZE(msm7x25_pm_data));
msm7x27_wlan_init();
swift_init_gpio_i2c_devices();
#ifdef CONFIG_ANDROID_RAM_CONSOLE
lge_add_ramconsole_devices();
lge_add_ers_devices();
lge_add_panic_handler_devices();
#endif
lge_add_camera_devices();
lge_add_lcd_devices();
lge_add_btpower_devices();
lge_add_mmc_devices();
lge_add_input_devices();
lge_add_misc_devices();
lge_add_pm_devices();
/* gpio i2c devices should be registered at latest point */
lge_add_gpio_i2c_devices();
/* initialize timed_output vibrator */
swift_init_timed_vibrator();
}
static void __init mahimahi_init(void)
{
int ret;
struct kobject *properties_kobj;
printk("mahimahi_init() revision=%d\n", system_rev);
if (is_cdma_version(system_rev))
smd_set_channel_list(smd_cdma_default_channels,
ARRAY_SIZE(smd_cdma_default_channels));
msm_hw_reset_hook = mahimahi_reset;
if (is_cdma_version(system_rev))
msm_acpu_clock_init(&mahimahi_cdma_clock_data);
else
msm_acpu_clock_init(&mahimahi_clock_data);
msm_serial_debug_init(MSM_UART1_PHYS, INT_UART1,
&msm_device_uart1.dev, 1, MSM_GPIO_TO_INT(139));
config_gpio_table(misc_gpio_table, ARRAY_SIZE(misc_gpio_table));
if (is_cdma_version(system_rev)) {
bcm_bt_lpm_pdata.gpio_wake = MAHIMAHI_CDMA_GPIO_BT_WAKE;
mahimahi_flashlight_data.torch = MAHIMAHI_CDMA_GPIO_FLASHLIGHT_TORCH;
config_gpio_table(bt_gpio_table_rev_CX, ARRAY_SIZE(bt_gpio_table_rev_CX));
} else {
config_gpio_table(bt_gpio_table, ARRAY_SIZE(bt_gpio_table));
}
gpio_request(MAHIMAHI_GPIO_TP_LS_EN, "tp_ls_en");
gpio_direction_output(MAHIMAHI_GPIO_TP_LS_EN, 0);
gpio_request(MAHIMAHI_GPIO_TP_EN, "tp_en");
gpio_direction_output(MAHIMAHI_GPIO_TP_EN, 0);
gpio_request(MAHIMAHI_GPIO_PROXIMITY_EN, "proximity_en");
gpio_direction_output(MAHIMAHI_GPIO_PROXIMITY_EN, 1);
gpio_request(MAHIMAHI_GPIO_COMPASS_RST_N, "compass_rst");
gpio_direction_output(MAHIMAHI_GPIO_COMPASS_RST_N, 1);
gpio_request(MAHIMAHI_GPIO_COMPASS_INT_N, "compass_int");
gpio_direction_input(MAHIMAHI_GPIO_COMPASS_INT_N);
gpio_request(MAHIMAHI_GPIO_DS2482_SLP_N, "ds2482_slp_n");
/* set the gpu power rail to manual mode so clk en/dis will not
* turn off gpu power, and hang it on resume */
mahimahi_kgsl_power_rail_mode(0);
mahimahi_kgsl_power(true);
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
platform_add_devices(devices, ARRAY_SIZE(devices));
i2c_register_board_info(0, base_i2c_devices,
ARRAY_SIZE(base_i2c_devices));
if (system_rev == 0) {
/* Only board after XB with Audience A1026 */
i2c_register_board_info(0, rev0_i2c_devices,
ARRAY_SIZE(rev0_i2c_devices));
}
if (system_rev > 0) {
/* Only board after XB with Audience A1026 */
i2c_register_board_info(0, rev1_i2c_devices,
ARRAY_SIZE(rev1_i2c_devices));
}
if (is_cdma_version(system_rev)) {
/* Only CDMA version with TI TPA2018D1 Speaker Amp. */
i2c_register_board_info(0, rev_CX_i2c_devices,
ARRAY_SIZE(rev_CX_i2c_devices));
if ((system_rev & 0x0F) == 0x00) {
a1026_data.gpio_a1026_clk = MAHIMAHI_CDMA_XA_AUD_A1026_CLK;
} else if ((system_rev & 0x0F) >= 0x01) {
a1026_data.gpio_a1026_wakeup = MAHIMAHI_CDMA_XB_AUD_A1026_WAKEUP;
a1026_data.gpio_a1026_reset = MAHIMAHI_CDMA_XB_AUD_A1026_RESET;
a1026_data.gpio_a1026_clk = MAHIMAHI_CDMA_XB_AUD_A1026_CLK;
}
}
ret = mahimahi_init_mmc(system_rev, debug_uart);
if (ret != 0)
pr_crit("%s: Unable to initialize MMC\n", __func__);
properties_kobj = kobject_create_and_add("board_properties", NULL);
if (properties_kobj)
ret = sysfs_create_group(properties_kobj,
&mahimahi_properties_attr_group);
if (!properties_kobj || ret)
pr_err("failed to create board_properties\n");
mahimahi_audio_init();
mahimahi_headset_init();
if (system_rev > 0)
platform_device_register(&mahimahi_timed_gpios);
else
msm_init_pmic_vibrator();
ds2784_battery_init();
}
static void __init bahamas_init(void)
{
int rc;
char *cid = NULL;
printk("bahamas_init() revision = 0x%X\n", system_rev);
printk(KERN_INFO "mfg_mode=%d\n", board_mfg_mode());
msm_clock_init();
board_get_cid_tag(&cid);
/*
* Setup common MSM GPIOS
*/
config_gpios();
gpio_request(BAHAMAS_GPIO_CABLE_IN2, "gpio_cable_in2");
gpio_request(BAHAMAS_GPIO_AUD_EXTMIC_SEL, "gpio_aud_extmic_sel");
gpio_request(BAHAMAS_GPIO_WFM_ANT_SW, "gpio_wfm_ant_sw");
msm_hw_reset_hook = bahamas_reset;
msm_acpu_clock_init(&bahamas_clock_data);
#if defined(CONFIG_PERFLOCK)
perflock_init(&bahamas_perflock_data);
#endif
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
if (!opt_disable_uart3)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1,
MSM_GPIO_TO_INT(BAHAMAS_GPIO_UART3_RX));
#endif
msm_add_devices();
#if defined(CONFIG_SERIAL_MSM_HS)
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
msm_add_serial_devices(3);
#else
msm_add_serial_devices(0);
#endif
msm_add_serial_devices(2);
#if defined(CONFIG_USB_FUNCTION)
msm_register_usb_phy_init_seq(bahamas_phy_init_seq);
msm_add_usb_devices(bahamas_phy_reset, NULL);
#endif
#if defined(CONFIG_USB_ANDROID)
android_usb_pdata.products[0].product_id =
android_usb_pdata.product_id;
android_usb_pdata.serial_number = board_serialno();
msm_hsusb_pdata.serial_number = board_serialno();
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
platform_device_register(&msm_device_hsusb);
#if defined(CONFIG_USB_ANDROID_RNDIS)
platform_device_register(&rndis_device);
#endif
platform_device_register(&usb_mass_storage_device);
platform_device_register(&android_usb_device);
#endif
if (board_mcp_monodie())
msm_add_mem_devices(&pmem_setting_monodie);
else
msm_add_mem_devices(&pmem_setting_dualdie);
bahamas_init_h2w_power_gpio();
rc = bahamas_init_mmc(system_rev);
if (rc)
printk(KERN_CRIT "%s: MMC init failure (%d)\n", __func__, rc);
if(system_rev < 3) {
if (panel_detect() == PANEL_WINTEK) {
microp_data.num_pins = ARRAY_SIZE(microp_pins_0_wint);
microp_data.pin_config = microp_pins_0_wint;
} else {
microp_data.num_pins = ARRAY_SIZE(microp_pins_0);
microp_data.pin_config = microp_pins_0;
}
i2c_microp_devices.irq = 0;
} else if (panel_detect() == PANEL_WINTEK) {
microp_data.num_pins = ARRAY_SIZE(microp_pins_1_wint);
microp_data.pin_config = microp_pins_1_wint;
}
msm_device_i2c_init();
platform_add_devices(devices, ARRAY_SIZE(devices));
if (system_rev >= 3)
bahamas_h2w_data.flags |= _35MM_MIC_DET_L2H;
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
i2c_register_board_info(0 ,&i2c_microp_devices, 1);
bahamas_init_keypad();
bahamas_init_panel();
msm_init_pmic_vibrator(3000);
}
static void __init bravo_init(void)
{
int ret;
printk("bravo_init() revision=%d\n", system_rev);
printk(KERN_INFO "%s: microp version = %s\n", __func__, microp_ver);
/* Must set msm_hw_reset_hook before first proc comm */
msm_hw_reset_hook = bravo_reset;
if (system_rev >= 2) {
mdp_pmem_pdata.start = MSM_PMEM_MDP_BASE + MSM_MEM_128MB_OFFSET;
android_pmem_adsp_pdata.start = MSM_PMEM_ADSP_BASE + MSM_MEM_128MB_OFFSET;
}
gpio_request(BRAVO_GPIO_LS_EN, "ls_en");
msm_acpu_clock_init(&bravo_clock_data);
perflock_init(&bravo_perflock_data);
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
msm_serial_debug_init(MSM_UART1_PHYS, INT_UART1,
&msm_device_uart1.dev, 1, MSM_GPIO_TO_INT(139));
#endif
#ifdef CONFIG_ARCH_QSD8X50
bt_export_bd_address();
#endif
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
msm_device_uart_dm1.name = "msm_serial_hs_bcm"; /* for bcm */
#endif
bravo_config_serial_debug_gpios();
config_gpio_table(camera_off_gpio_table,
ARRAY_SIZE(camera_off_gpio_table));
gpio_request(BRAVO_GPIO_TP_LS_EN, "tp_ls_en");
gpio_direction_output(BRAVO_GPIO_TP_LS_EN, 0);
gpio_request(BRAVO_GPIO_TP_EN, "tp_en");
gpio_direction_output(BRAVO_GPIO_TP_EN, 0);
bravo_audio_init();
msm_device_i2c_init();
#ifdef CONFIG_MICROP_COMMON
bravo_microp_init();
#endif
/* set the gpu power rail to manual mode so clk en/dis will not
* turn off gpu power, and hang it on resume */
bravo_kgsl_power_rail_mode(0);
bravo_kgsl_power(true);
platform_add_devices(devices, ARRAY_SIZE(devices));
bravo_init_panel();
if (!opt_usb_h2w_sw) {
#ifdef CONFIG_USB_FUNCTION
msm_register_usb_phy_init_seq(bravo_phy_init_seq);
msm_add_usb_devices(bravo_usb_phy_reset, NULL);
#endif
#ifdef CONFIG_USB_ANDROID
bravo_add_usb_devices();
#endif
}
for (ret = 0; ret < ARRAY_SIZE(i2c_devices); ret++) {
if (!strcmp(i2c_devices[ret].type, AKM8973_I2C_NAME))
i2c_devices[ret].irq = MSM_GPIO_TO_INT(BRAVO_GPIO_COMPASS_INT);
}
compass_platform_data.intr = BRAVO_GPIO_COMPASS_INT;
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
ret = bravo_init_mmc(system_rev);
if (ret != 0)
pr_crit("%s: Unable to initialize MMC\n", __func__);
ret = platform_device_register(&android_timed_gpios);
if (ret != 0)
pr_err("failed to register vibrator\n");
headset_init();
}
static void __init buzz_init(void)
{
int rc;
char *cid = NULL;
struct kobject *properties_kobj;
printk("buzz_init() revision = 0x%X\n", system_rev);
msm_clock_init();
board_get_cid_tag(&cid);
/* for bcm */
bt_export_bd_address();
/*
* Setup common MSM GPIOS
*/
config_gpios();
/* We need to set this pin to 0 only once on power-up; we will
* not actually enable the chip until we apply power to it via
* vreg.
*/
gpio_request(BUZZ_GPIO_LS_EN, "ls_en");
gpio_direction_output(BUZZ_GPIO_LS_EN, 0);
gpio_request(BUZZ_PS_2V85_EN, "ps_2v85_en");
msm_hw_reset_hook = buzz_reset;
msm_acpu_clock_init(&buzz_clock_data);
#ifdef CONFIG_PERFLOCK
perflock_init(&buzz_perflock_data);
#endif
#if defined(CONFIG_MSM_SERIAL_DEBUGGER)
if (!opt_disable_uart3)
msm_serial_debug_init(MSM_UART3_PHYS, INT_UART3,
&msm_device_uart3.dev, 1,
MSM_GPIO_TO_INT(BUZZ_GPIO_UART3_RX));
#endif
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
#ifndef CONFIG_SERIAL_MSM_HS_PURE_ANDROID
msm_device_uart_dm1.name = "msm_serial_hs_bcm"; /* for bcm */
#endif
msm_add_serial_devices(3);
#else
msm_add_serial_devices(0);
#endif
msm_add_serial_devices(2);
#ifdef CONFIG_USB_FUNCTION
msm_register_usb_phy_init_seq(buzz_phy_init_seq);
msm_add_usb_id_pin_gpio(BUZZ_GPIO_USB_ID_PIN);
msm_add_usb_devices(buzz_phy_reset, NULL);
#endif
#ifdef CONFIG_USB_ANDROID
android_usb_pdata.products[0].product_id =
android_usb_pdata.product_id;
android_usb_pdata.serial_number = board_serialno();
msm_hsusb_pdata.serial_number = board_serialno();
msm_device_hsusb.dev.platform_data = &msm_hsusb_pdata;
platform_device_register(&msm_device_hsusb);
#ifdef CONFIG_USB_ANDROID_RNDIS
platform_device_register(&rndis_device);
#endif
platform_device_register(&usb_mass_storage_device);
platform_device_register(&android_usb_device);
#endif
msm_add_mem_devices(&pmem_setting);
#ifdef CONFIG_MICROP_COMMON
buzz_microp_init();
#endif
rc = buzz_init_mmc(system_rev);
if (rc)
printk(KERN_CRIT "%s: MMC init failure (%d)\n", __func__, rc);
properties_kobj = kobject_create_and_add("board_properties", NULL);
if (properties_kobj)
rc = sysfs_create_group(properties_kobj,
&buzz_properties_attr_group);
if (!properties_kobj || rc)
pr_err("failed to create board_properties\n");
msm_device_i2c_init();
platform_add_devices(devices, ARRAY_SIZE(devices));
i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
if (system_rev < 3) {
i2c_microp_devices.platform_data = µp_data_xc;
platform_device_register(&buzz_leds);
}
if (system_rev >= 4) {
platform_device_register(&buzz_oj);
}
i2c_register_board_info(0, &i2c_microp_devices, 1);
/* probe camera driver */
i2c_register_board_info(0, i2c_camera_devices, ARRAY_SIZE(i2c_camera_devices));
buzz_init_keypad();
buzz_wifi_init();
buzz_panel_init();
msm_init_pmic_vibrator(3000);
}
