static void bravo_add_usb_devices(void)
{
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_bravo_usb_id_gpios(0);
config_gpio_table(usb_phy_3v3_table, ARRAY_SIZE(usb_phy_3v3_table));
gpio_set_value(BRAVO_USB_PHY_3V3_ENABLE, 1);
platform_device_register(&msm_device_hsusb);
platform_device_register(&usb_mass_storage_device);
platform_device_register(&android_usb_device);
}
static void msm8916_add_usb_devices(void)
{
int mode = board_mfg_mode();
android_usb_pdata.serial_number = board_serialno();
if (mode != 0) {
android_usb_pdata.nluns = 1;
android_usb_pdata.cdrom_lun = 0x0;
}
if ((!(get_radio_flag() & BIT(17))) && (mode == MFG_MODE_MFGKERNEL || mode == MFG_MODE_MFGKERNEL_DIAG58)) {
android_usb_pdata.fserial_init_string = "tty,tty:autobot,tty:serial,tty:autobot,tty:acm";
}
#ifdef CONFIG_MACH_A11_UL
android_usb_pdata.product_id = 0x05fd;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0652;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0653;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0654;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0655;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x05F5;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x05F6;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x05F7;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x05F8;
#endif
platform_device_register(&android_usb_device);
}
static void htcleo_add_usb_devices(void)
{
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_gpio_table(usb_phy_3v3_table, ARRAY_SIZE(usb_phy_3v3_table));
gpio_set_value(HTCLEO_GPIO_USBPHY_3V3_ENABLE, 1);
platform_device_register(&msm_device_hsusb);
platform_device_register(&usb_mass_storage_device);
#ifdef CONFIG_USB_ANDROID_RNDIS
platform_device_register(&rndis_device);
#endif
platform_device_register(&android_usb_device);
}
static void htc_8974_add_usb_devices(void)
{
android_usb_pdata.serial_number = board_serialno();
if (board_mfg_mode() == 0) {
#ifdef CONFIG_MACH_M8_WHL
android_usb_pdata.nluns = 2;
android_usb_pdata.cdrom_lun = 0x2;
#else
android_usb_pdata.nluns = 1;
android_usb_pdata.cdrom_lun = 0x1;
#endif
}
#ifdef CONFIG_MACH_M8
android_usb_pdata.product_id = 0x061A;
#elif defined(CONFIG_MACH_M8_WL)
android_usb_pdata.product_id = 0x0616;
android_usb_pdata.vzw_unmount_cdrom = 1;
#elif defined(CONFIG_MACH_M8_UHL)
android_usb_pdata.product_id = 0x063A;
#else
#endif
platform_device_register(&android_usb_device);
}
static void msm8226_add_usb_devices(void)
{
__maybe_unused int id;
android_usb_pdata.serial_number = board_serialno();
#ifdef CONFIG_MACH_MEM_UL
android_usb_pdata.product_id = 0x0629;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x060c;
android_usb_pdata.vzw_unmount_cdrom = 1;
android_usb_pdata.nluns = 2;
android_usb_pdata.cdrom_lun = 0x3;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x063d;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x063e;
android_usb_pdata.vzw_unmount_cdrom = 1;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0647;
#else
id = of_machine_projectid(0);
switch (id) {
case 297:
android_usb_pdata.product_id = 0x062d;
break;
case 298:
android_usb_pdata.product_id = 0x0633;
break;
case 290:
android_usb_pdata.product_id = 0x0632;
break;
case 296:
android_usb_pdata.product_id = 0x062e;
break;
case 295:
android_usb_pdata.product_id = 0x0631;
break;
case 291:
android_usb_pdata.product_id = 0x0630;
android_usb_pdata.nluns = 2;
android_usb_pdata.cdrom_lun = 0x2;
break;
case 294:
android_usb_pdata.product_id = 0x062f;
break;
case 318:
android_usb_pdata.product_id = 0x0645;
break;
default:
android_usb_pdata.product_id = 0x0dff;
break;
}
#endif
platform_device_register(&android_usb_device);
}
void __init msm_add_usb_devices(void (*phy_reset) (void))
{
/* setup */
android_usb_pdata.serial_number = board_serialno();
if (phy_reset)
msm_hsusb_pdata.phy_reset = phy_reset;
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);
}
static void htc_8974_add_usb_devices(void)
{
char *mid = board_mid();
android_usb_pdata.serial_number = board_serialno();
if (board_mfg_mode() == 0) {
android_usb_pdata.nluns = 1;
android_usb_pdata.cdrom_lun = 0x1;
}
#ifdef CONFIG_MACH_M8
android_usb_pdata.product_id = 0x061A;
#elif defined(CONFIG_MACH_M8_WL)
android_usb_pdata.product_id = 0x0616;
android_usb_pdata.vzw_unmount_cdrom = 1;
#elif defined(CONFIG_MACH_M8_UHL)
android_usb_pdata.product_id = 0x063A;
#elif defined(CONFIG_MACH_M8_DUG)
android_usb_pdata.product_id = 0x063B;
#elif defined(CONFIG_MACH_EYE_UL)
android_usb_pdata.product_id = 0x064C;
#elif defined(CONFIG_MACH_MEC_TL)
android_usb_pdata.product_id = 0x0635;
#elif defined(CONFIG_MACH_MEC_UL)
android_usb_pdata.product_id = 0x0638;
#elif defined(CONFIG_MACH_MEC_DUG)
android_usb_pdata.product_id = 0x0636;
#elif defined(CONFIG_MACH_MEC_DWG)
android_usb_pdata.product_id = 0x0644;
#elif defined(CONFIG_MACH_MEC_WHL)
android_usb_pdata.product_id = 0x0646;
#endif
if (strcmp("0PFH20000", mid)==0)
android_usb_pdata.product_id = 0x064B;
else if (strcmp("0P6B90000", mid)==0 || strcmp("0P6B91000", mid)==0)
android_usb_pdata.product_id = 0x064A;
platform_device_register(&android_usb_device);
}
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 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 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 htc_8974_add_usb_devices(void)
{
char *mid;
android_usb_pdata.serial_number = board_serialno();
mid = board_mid();
if (board_mfg_mode() == 0) {
#ifdef CONFIG_MACH_M8_WHL
android_usb_pdata.nluns = 2;
android_usb_pdata.cdrom_lun = 0x2;
#elif defined(CONFIG_MACH_B2_WLJ)
android_usb_pdata.nluns = 2;
android_usb_pdata.cdrom_lun = 0x2;
#elif defined(CONFIG_MACH_MEC_WHL)
android_usb_pdata.nluns = 2;
android_usb_pdata.cdrom_lun = 0x2;
#else
android_usb_pdata.nluns = 1;
android_usb_pdata.cdrom_lun = 0x1;
#endif
}
#ifdef CONFIG_MACH_M8
android_usb_pdata.product_id = 0x061A;
#elif defined(CONFIG_MACH_M8_WL)
android_usb_pdata.product_id = 0x0616;
android_usb_pdata.vzw_unmount_cdrom = 1;
#elif defined(CONFIG_MACH_M8_WHL)
android_usb_pdata.product_id = 0x061A;
#elif defined(CONFIG_MACH_M8_TL)
android_usb_pdata.product_id = 0x0623;
#elif defined(CONFIG_MACH_M8_DUG)
android_usb_pdata.product_id = 0x063B;/* M8_DUGL */
#elif defined(CONFIG_MACH_M8_DWG)
android_usb_pdata.product_id = 0x0643;/* M8_DWGL */
#elif defined(CONFIG_MACH_M8_UHL)
android_usb_pdata.product_id = 0x063A;
#elif defined(CONFIG_MACH_MEC_TL)
android_usb_pdata.product_id = 0x0635;
#elif defined(CONFIG_MACH_MEC_UL)
android_usb_pdata.product_id = 0x0638;
#elif defined(CONFIG_MACH_MEC_DUG)
android_usb_pdata.product_id = 0x0636;/* MEC_DUGL */
#elif defined(CONFIG_MACH_B2_WLJ)
android_usb_pdata.product_id = 0x0634;
#elif defined(CONFIG_MACH_B2_UHL)
android_usb_pdata.product_id = 0x0642;
#elif defined(CONFIG_MACH_B2_UL)
android_usb_pdata.product_id = 0x0642;/* use B2_UHL first */
#elif defined(CONFIG_MACH_MEC_DWG)
android_usb_pdata.product_id = 0x0644;/* MEC_DWGL */
#elif defined(CONFIG_MACH_MEC_WHL)
android_usb_pdata.product_id = 0x0646;
#elif defined(CONFIG_MACH_MELS_TUHL)
android_usb_pdata.product_id = 0x0651;
#elif defined(CONFIG_MACH_EYE_UL)
android_usb_pdata.product_id = 0x064C;/* EYE_UL_ATT */
#else
/* DUG, WHL */
#endif
if (strcmp("0PFH20000", mid)==0)
android_usb_pdata.product_id = 0x064B;/* EYE_TUHL */
else if (strcmp("0P6B90000", mid)==0 || strcmp("0P6B91000", mid)==0)
android_usb_pdata.product_id = 0x064A;/* M8LS_UHL */
platform_device_register(&android_usb_device);
}
/* 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 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;
}
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));
/* 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_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));
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 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 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();
serialno_setup(board_serialno());
}
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);
}
static void htc_8974_add_usb_devices(void)
{
char *mid;
android_usb_pdata.serial_number = board_serialno();
mid = board_mid();
if (board_mfg_mode() == 0) {
#ifdef CONFIG_MACH_DUMMY
android_usb_pdata.nluns = 2;
android_usb_pdata.cdrom_lun = 0x2;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.nluns = 2;
android_usb_pdata.cdrom_lun = 0x2;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.nluns = 2;
android_usb_pdata.cdrom_lun = 0x2;
#else
android_usb_pdata.nluns = 1;
android_usb_pdata.cdrom_lun = 0x1;
#endif
}
#ifdef CONFIG_MACH_M8
android_usb_pdata.product_id = 0x061A;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0616;
android_usb_pdata.vzw_unmount_cdrom = 1;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x061A;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0623;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x063B;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0643;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0635;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0638;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0636;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0634;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0642;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0644;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0646;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x0651;
#elif defined(CONFIG_MACH_DUMMY)
android_usb_pdata.product_id = 0x064C;
#else
#endif
if (strcmp("0PFH20000", mid)==0)
android_usb_pdata.product_id = 0x064B;
else if (strcmp("0P6B90000", mid)==0 || strcmp("0P6B91000", mid)==0)
android_usb_pdata.product_id = 0x064A;
platform_device_register(&android_usb_device);
}
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();
}