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