static void __init zeebo_init(void)
{
msm_acpu_clock_init(&halibut_clock_data);
msm_proc_comm_wince_init();
#ifdef CONFIG_MSM_SMEM_BATTCHG
msm_device_htc_battery_smem.dev.platform_data = &zeebo_htc_battery_smem_pdata;
#endif
//msm_device_touchscreen.dev.platform_data = &zeebo_ts_pdata;
#ifdef CONFIG_SERIAL_MSM_HS
msm_device_uart_dm2.dev.platform_data = &msm_uart_dm2_pdata;
#endif
platform_add_devices(devices, ARRAY_SIZE(devices));
//i2c_register_board_info(0, i2c_devices, ARRAY_SIZE(i2c_devices));
//msm_add_usb_devices(&zeebo_hsusb_board_pdata);
//msm_rpc_create_server(&ffff_server);
//msm_rpc_create_server(&fffe_server);
//msm_init_pmic_vibrator();
//msm_proc_comm_wince_vibrate_welcome();
}
static void __init qsd8x50_init(void)
{
if (socinfo_init() < 0)
printk(KERN_ERR "%s: socinfo_init() failed!\n",
__func__);
qsd8x50_cfg_smc91x();
msm_acpu_clock_init(&qsd8x50_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_fb_add_devices();
msm_camera_add_device();
qsd8x50_init_mmc();
bt_power_init();
audio_gpio_init();
msm_device_i2c_init();
i2c_register_board_info(0, msm_i2c_board_info,
ARRAY_SIZE(msm_i2c_board_info));
spi_register_board_info(msm_spi_board_info,
ARRAY_SIZE(msm_spi_board_info));
msm_pm_set_platform_data(msm_pm_data);
#ifdef CONFIG_SURF_FFA_GPIO_KEYPAD
if (machine_is_qsd8x50_ffa())
platform_device_register(&keypad_device_8k_ffa);
else
platform_device_register(&keypad_device_surf);
#endif
}
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 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 msm7x2x_init(void)
{
if (socinfo_init() < 0)
printk(KERN_ERR "%s: socinfo_init() failed!\n",
__func__);
msm_clock_init(msm_clocks_7x27a, msm_num_clocks_7x27a);
msm_acpu_clock_init(&msm7x2x_clock_data);
/* Common functions for SURF/FFA/RUMI3 */
msm_device_i2c_init();
msm7x27a_init_ebi2();
#ifdef CONFIG_SERIAL_MSM_HS
msm_uart_dm1_pdata.wakeup_irq = gpio_to_irq(UART1DM_RX_GPIO);
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
#endif
msm_add_pmem_devices();
msm_add_fb_device();
platform_add_devices(m3eu_devices,
ARRAY_SIZE(m3eu_devices));
/*7x25a kgsl initializations*/
msm7x25a_kgsl_3d0_init();
if (lge_get_uart_mode()) {
if (lge_bd_rev == LGE_REV_A)
platform_device_register(&msm_device_uart3);
else
platform_device_register(&msm_device_uart1);
}
lge_add_input_devices();
lge_add_misc_devices();
lge_add_mmc_devices();
lge_add_sound_devices();
lge_add_lcd_devices();
lge_add_camera_devices();
lge_add_pm_devices();
lge_add_usb_devices();
lge_add_connectivity_devices(); /* [email protected], for Bluetooth/FM */
/* gpio i2c devices should be registered at latest point */
lge_add_gpio_i2c_devices();
lge_add_ramconsole_devices();
#if defined(CONFIG_ANDROID_RAM_CONSOLE) && defined(CONFIG_LGE_HANDLE_PANIC)
lge_add_panic_handler_devices();
#endif
/* [email protected] [2011-09-22] - Read power on status and update boot reason */
#ifdef CONFIG_LGE_POWER_ON_STATUS_PATCH
lge_board_pwr_on_status();
#endif
}
static void __init msm7x2x_init(void)
{
if (socinfo_init() < 0)
printk(KERN_ERR "%s: socinfo_init() failed!\n",
__func__);
msm_clock_init(msm_clocks_7x27a, msm_num_clocks_7x27a);
msm_acpu_clock_init(&msm7x2x_clock_data);
/* Common functions for SURF/FFA/RUMI3 */
msm_device_i2c_init();
msm7x27a_init_ebi2();
#ifdef CONFIG_SERIAL_MSM_HS
msm_uart_dm1_pdata.wakeup_irq = gpio_to_irq(UART1DM_RX_GPIO);
msm_device_uart_dm1.dev.platform_data = &msm_uart_dm1_pdata;
#endif
msm_add_pmem_devices();
msm_add_fb_device();
platform_add_devices(m3_devices,
ARRAY_SIZE(m3_devices));
/*7x25a kgsl initializations*/
msm7x25a_kgsl_3d0_init();
platform_device_register(&msm_device_uart1);
lge_add_input_devices();
lge_add_misc_devices();
lge_add_mmc_devices();
lge_add_sound_devices();
lge_add_lcd_devices();
lge_add_camera_devices();
//lge_add_pm_devices();
lge_add_usb_devices();
lge_add_connectivity_devices(); /* */
/* gpio i2c devices should be registered at latest point */
lge_add_gpio_i2c_devices();
lge_add_ramconsole_devices();
#if defined(CONFIG_ANDROID_RAM_CONSOLE) && defined(CONFIG_LGE_HANDLE_PANIC)
lge_add_panic_handler_devices();
#endif
/* */
#ifdef CONFIG_LGE_POWER_ON_STATUS_PATCH
lge_board_pwr_on_status();
#endif
#ifdef CONFIG_LGE_SILENCE_RESET
check_smem_ers_status();
#endif
}
int __init msm7x2x_misc_init(void)
{
if (socinfo_init() < 0)
pr_err("%s: socinfo_init() failed!\n", __func__);
msm_clock_init(msm_clocks_7x27a, msm_num_clocks_7x27a);
msm_acpu_clock_init(&msm7x2x_clock_data);
return 0;
}
int __init msm7x2x_misc_init(void)
{
if (socinfo_init() < 0)
pr_err("%s: socinfo_init() failed!\n", __func__);
if (cpu_is_msm7x27aa())
msm7x2x_clock_data.max_speed_delta_khz = 504000;
msm_clock_init(msm_clocks_7x27a, msm_num_clocks_7x27a);
msm_acpu_clock_init(&msm7x2x_clock_data);
return 0;
}
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 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);
}
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 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 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 msm7x30_init(void)
{
uint32_t soc_version = 0;
if (socinfo_init() < 0)
printk(KERN_ERR "%s: socinfo_init() failed!\n",
__func__);
soc_version = socinfo_get_version();
msm_clock_init(msm_clocks_7x30, msm_num_clocks_7x30);
#ifdef CONFIG_SERIAL_MSM_CONSOLE
if (lge_get_uart_mode())
msm7x30_init_uart2();
#endif
msm_spm_init(&msm_spm_data, 1);
msm_acpu_clock_init(&msm7x30_clock_data);
msm_add_pmem_devices();
msm_add_fb_device();
msm_add_kgsl_device();
msm_add_usb_devices();
msm7x30_init_marimba();
#ifdef CONFIG_MSM7KV2_AUDIO
lge_victor_audio_init();
msm_snddev_init();
aux_pcm_gpio_init();
#endif
if (lge_get_uart_mode())
platform_device_register(&msm_device_uart2);
platform_add_devices(devices, ARRAY_SIZE(devices));
msm_device_i2c_init();
msm_device_i2c_2_init();
qup_device_i2c_init();
register_board_info();
#ifdef CONFIG_I2C_SSBI
msm_device_ssbi6.dev.platform_data = &msm_i2c_ssbi6_pdata;
msm_device_ssbi7.dev.platform_data = &msm_i2c_ssbi7_pdata;
#endif
/* initialize pm */
pmic8058_buses_init();
pmic8058_leds_init(); // LGE_UPDATE [email protected]. PMIC LED Control Drv.
lge_pm_set_platform_data();
pm8058_special_clock0_setting();
/* add lcd devices */
lge_add_lcd_devices();
/* add mmc devices */
lge_add_mmc_devices();
/* add misc devices */
lge_add_misc_devices();
/* add input devices */
lge_add_input_devices();
/* gpio i2c devices should be registered at latest point */
lge_add_gpio_i2c_devices();
/* add buletooth devices */
lge_add_btpower_devices();
/* add camera devices */
lge_add_camera_devices();
/* add ram console device */
#ifdef CONFIG_ANDROID_RAM_CONSOLE
lge_add_ramconsole_devices();
#endif
#if defined(CONFIG_ANDROID_RAM_CONSOLE) && defined(CONFIG_LGE_HANDLE_PANIC)
lge_add_panic_handler_devices();
#endif
}
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 bahamas_init(void)
{
int rc;
printk("bahamas_init() revision=%d\n", system_rev);
/*
* Setup common MSM GPIOS
*/
sdc1_boot_reset();
// printk("\n\nboard-mega.c: sdc1 boot reset\n\n");
config_gpios();
// printk("\n\nboard-mega.c: config gpios\n\n");
msm_hw_reset_hook = bahamas_reset;
// printk("\n\nboard-mega.c: msm hw reset hook\n\n");
msm_acpu_clock_init(&bahamas_clock_data);
// printk("\n\nmsm acpu clock init\n\n");
perflock_init(&bahamas_perflock_data);
// printk("\n\nperflock init\n\n");
/* adjust GPIOs based on bootloader request */
/* XXX: on Memphis,
* GPIO#86 is H2W DAT / UART RX for HTC 11-Pin
* GPIO#87 is H2W CLK / UART TX for HTC 11-Pin
* We would need to use UART3 as debug port
*
* TODO: switch UART3 and H2W (for headset detect)
* 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);
#endif*/
/* touchscreen must be powered before we enable i2c pullup */
#if 0 /* TODO: do some equivalent operations here */
udelay(50);
trout_gpio_write(NULL, TROUT_GPIO_I2C_PULL, 1);
#endif
/* put the AF VCM in powerdown mode to avoid noise */
#if 0
trout_gpio_write(NULL, TROUT_GPIO_VCM_PWDN, 1);
mdelay(100);
trout_i2c_sysdev_resume(NULL);
#endif
#if 0 /* TODO: do some equivalent operations here */
if(sysdev_class_register(&trout_i2c_sysdev_class) == 0)
sysdev_register(&trout_i2c_sys_device);
#endif
#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_add_usb_devices(NULL,NULL);
//msm_change_usb_id(0x0bb4, 0x0c06);
if (board_mcp_monodie())
msm_add_mem_devices(&pmem_setting_monodie);
else
msm_add_mem_devices(&pmem_setting_dualdie);
msm_init_pmic_vibrator();
// printk("\n\nboard-mega.c: msm init pmic vibrator\n\n");
bahamas_init_h2w_power_gpio();
// printk("\n\nboard-mega.c: bahamas init h2w power gpio\n\n");
//#if 1
rc = bahamas_init_mmc(system_rev);
// printk("\n\nboard-mega.c: init mmc\n\n");
if (rc)
printk(KERN_CRIT "%s: MMC init failure (%d)\n", __func__, rc);
//#endif
if(!system_rev)
bahamas_reset_keys_device.dev.platform_data = &bahamas_reset_keys_pdata0;
/*CC090319*/
/* if (bahamas_is_3M_camera()) {
msm_camera_device_data.sinfo = &msm_camera_sensor_mt9t013;
}
else {
msm_camera_device_data.sinfo = &msm_camera_sensor_s5k4b2fx;
}*/
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;
}
/*~CC090319*/
//platform_add_devices(devices, ARRAY_SIZE(devices));
/* Read Config 8 200 (Full Speed USB Mode) */
/*if (readl(MSM_SHARED_RAM_BASE + 0xFC054) & 0x200)
bahamas_h2w_data.flags |= FULL_SPEED_USB;
if (system_rev >= 3)
bahamas_h2w_data.flags |= _35MM_MIC_DET_L2H;
/* if (system_rev >= 5)
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);
/* SD card door should wake the device */
//trout_gpio_irq_set_wake(TROUT_GPIO_TO_INT(TROUT_GPIO_SD_DOOR_N), 1);
msm_hsusb_set_vbus_state(1);
}
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;
} 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();
}
/* 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);
}
static void __init msm7x30_init(void)
{
uint32_t soc_version = 0;
if (socinfo_init() < 0)
printk(KERN_ERR "%s: socinfo_init() failed!\n",
__func__);
soc_version = socinfo_get_version();
msm_clock_init(msm_clocks_7x30, msm_num_clocks_7x30);
#ifdef CONFIG_SERIAL_MSM_CONSOLE
if (lge_get_uart_mode())
msm7x30_init_uart2();
#endif
msm_spm_init(&msm_spm_data, 1);
msm_acpu_clock_init(&msm7x30_clock_data);
msm_add_pmem_devices();
msm_add_fb_device();
msm_add_kgsl_device();
msm_add_usb_devices();
#if defined(CONFIG_LGE_MODEL_E739)
msm7x30_init_marimba();
#endif
#ifdef CONFIG_MSM7KV2_AUDIO
lge_victor_audio_init();
msm_snddev_init();
aux_pcm_gpio_init();
#endif
if (lge_get_uart_mode())
platform_device_register(&msm_device_uart2);
//LGE_FW_TDMB [START]
#if defined(CONFIG_TSIF) || defined(CONFIG_TSIF_MODULE)
msm_device_tsif.dev.platform_data = &tsif_platform_data;
#endif
//LGE_FW_TDMB [END]
platform_add_devices(devices, ARRAY_SIZE(devices));
msm_device_i2c_init();
msm_device_i2c_2_init();
qup_device_i2c_init();
#if defined(CONFIG_LGE_MODEL_E739)
register_board_info();
#else
msm7x30_init_marimba();
#endif
#ifdef CONFIG_I2C_SSBI
msm_device_ssbi6.dev.platform_data = &msm_i2c_ssbi6_pdata;
msm_device_ssbi7.dev.platform_data = &msm_i2c_ssbi7_pdata;
#endif
/* initialize pm */
pmic8058_buses_init();
lge_pm_set_platform_data();
/* add lcd devices */
lge_add_lcd_devices();
/* add mmc devices */
lge_add_mmc_devices();
/* add misc devices */
lge_add_misc_devices();
/* add input devices */
lge_add_input_devices();
//LGE_FW_TDMB [START]
#ifdef CONFIG_LGE_BROADCAST
lge_add_broadcast_dmb_devices();
#endif
//LGE_FW_TDMB [END]
/* gpio i2c devices should be registered at latest point */
lge_add_gpio_i2c_devices();
/* add buletooth devices */
lge_add_btpower_devices();
/* add camera devices */
lge_add_camera_devices();
/* add ram console device */
#ifdef CONFIG_ANDROID_RAM_CONSOLE
lge_add_ramconsole_devices();
#endif
#if defined(CONFIG_ANDROID_RAM_CONSOLE) && defined(CONFIG_LGE_HANDLE_PANIC)
lge_add_panic_handler_devices();
#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;
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 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 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();
}
/* 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 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);
}
