void bravo_speaker_enable(int en)
{
struct spkr_config_mode scm;
memset(&scm, 0, sizeof(scm));
D("%s %d\n", __func__, en);
if (en) {
scm.is_right_chan_en = 0;
scm.is_left_chan_en = 1;
scm.is_stereo_en = 0;
scm.is_hpf_en = 1;
pmic_spkr_en_mute(LEFT_SPKR, 0);
pmic_spkr_en_mute(RIGHT_SPKR, 0);
pmic_set_spkr_configuration(&scm);
pmic_spkr_en(LEFT_SPKR, 1);
pmic_spkr_en(RIGHT_SPKR, 0);
/* unmute */
pmic_spkr_en_mute(LEFT_SPKR, 1);
} else {
pmic_spkr_en_mute(LEFT_SPKR, 0);
pmic_spkr_en(LEFT_SPKR, 0);
pmic_spkr_en(RIGHT_SPKR, 0);
pmic_set_spkr_configuration(&scm);
}
if (is_cdma_version(system_rev))
tpa2018d1_set_speaker_amp(en);
}
void mahimahi_receiver_enable(int en)
{
if (is_cdma_version(system_rev) &&
((system_rev == 0xC1) || (system_rev == 0xC2))) {
struct spkr_config_mode scm;
memset(&scm, 0, sizeof(scm));
D("%s %d\n", __func__, en);
if (en) {
scm.is_right_chan_en = 1;
scm.is_left_chan_en = 0;
scm.is_stereo_en = 0;
scm.is_hpf_en = 1;
pmic_spkr_en_mute(RIGHT_SPKR, 0);
pmic_set_spkr_configuration(&scm);
pmic_spkr_en(RIGHT_SPKR, 1);
/* unmute */
pmic_spkr_en_mute(RIGHT_SPKR, 1);
} else {
pmic_spkr_en_mute(RIGHT_SPKR, 0);
pmic_spkr_en(RIGHT_SPKR, 0);
pmic_set_spkr_configuration(&scm);
}
}
}
static void mahimahi_headset_init(void)
{
if (is_cdma_version(system_rev))
return;
config_gpio_table(key_int_shutdown_gpio_table,
ARRAY_SIZE(key_int_shutdown_gpio_table));
gpio_set_value(MAHIMAHI_GPIO_35MM_KEY_INT_SHUTDOWN, 0);
}
void __init bravo_audio_init(void)
{
mutex_init(&mic_lock);
mutex_init(&bt_sco_lock);
q6audio_register_analog_ops(&ops);
acoustic_register_ops(&acoustic);
if (is_cdma_version(system_rev))
q6audio_set_acdb_file("default_PMIC.acdb");
}
static void config_mahimahi_flashlight_gpios(void)
{
if (is_cdma_version(system_rev)) {
config_gpio_table(flashlight_gpio_table_rev_CX,
ARRAY_SIZE(flashlight_gpio_table_rev_CX));
} else {
config_gpio_table(flashlight_gpio_table,
ARRAY_SIZE(flashlight_gpio_table));
}
}
int __init bravo_init_mmc(unsigned int sys_rev, unsigned debug_uart)
{
uint32_t id;
printk("%s()+\n", __func__);
/* initial WIFI_SHUTDOWN# */
id = PCOM_GPIO_CFG(BRAVO_GPIO_WIFI_SHUTDOWN_N, 0, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA),
msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &id, 0);
msm_add_sdcc(1, &bravo_wifi_data, 0, 0);
if (debug_uart) {
pr_info("%s: sdcard disabled due to debug uart\n", __func__);
goto done;
}
if (opt_disable_sdcard) {
pr_info("%s: sdcard disabled on cmdline\n", __func__);
goto done;
}
sdslot_vreg_enabled = 0;
if (is_cdma_version(sys_rev)) {
/* In the CDMA version, sdslot is supplied by a gpio. */
int rc = gpio_request(BRAVO_CDMA_SD_2V85_EN, "sdslot_en");
if (rc < 0) {
pr_err("%s: gpio_request(%d) failed: %d\n", __func__,
BRAVO_CDMA_SD_2V85_EN, rc);
return rc;
}
bravo_sdslot_data.translate_vdd = bravo_cdma_sdslot_switchvdd;
} else {
/* in UMTS version, sdslot is supplied by pmic */
sdslot_vreg = vreg_get(0, "gp6");
if (IS_ERR(sdslot_vreg))
return PTR_ERR(sdslot_vreg);
}
// if (system_rev > 0)
bravo_sdslot_data.status = bravo_sdslot_status;
msm_add_sdcc(2, &bravo_sdslot_data, 0, 0);
// else {
// bravo_sdslot_data.status = bravo_sdslot_status;
// bravo_sdslot_data.register_status_notify = NULL;
// set_irq_wake(MSM_GPIO_TO_INT(BRAVO_GPIO_SDMC_CD_N), 1);
// msm_add_sdcc(2, &bravo_sdslot_data,
// MSM_GPIO_TO_INT(BRAVO_GPIO_SDMC_CD_N),
// IORESOURCE_IRQ_LOWEDGE | IORESOURCE_IRQ_HIGHEDGE);
// }
done:
printk("%s()-\n", __func__);
return 0;
}
static int config_bravo_flashlight_gpios(void)
{
if (is_cdma_version(system_rev)) {
config_gpio_table(flashlight_gpio_table_rev_CX,
ARRAY_SIZE(flashlight_gpio_table_rev_CX));
} else {
config_gpio_table(flashlight_gpio_table,
ARRAY_SIZE(flashlight_gpio_table));
}
return 0;
}
static int ds2784_charge(int on, int fast)
{
if (is_cdma_version(system_rev)) {
if (!on)
smb329_set_charger_ctrl(SMB329_DISABLE_CHG);
else
smb329_set_charger_ctrl(fast ? SMB329_ENABLE_FAST_CHG : SMB329_ENABLE_SLOW_CHG);
}
else
gpio_direction_output(MAHIMAHI_GPIO_BATTERY_CHARGER_CURRENT, !!fast);
gpio_direction_output(MAHIMAHI_GPIO_BATTERY_CHARGER_EN, !on);
return 0;
}
static int w1_ds2784_add_slave(struct w1_slave *sl)
{
struct dd {
struct platform_device pdev;
struct ds2784_platform_data pdata;
} *p;
int rc;
p = kzalloc(sizeof(struct dd), GFP_KERNEL);
if (!p) {
pr_err("%s: out of memory\n", __func__);
return -ENOMEM;
}
rc = gpio_request(MAHIMAHI_GPIO_BATTERY_CHARGER_EN, "charger_en");
if (rc < 0) {
pr_err("%s: gpio_request(%d) failed: %d\n", __func__,
MAHIMAHI_GPIO_BATTERY_CHARGER_EN, rc);
kfree(p);
return rc;
}
if (!is_cdma_version(system_rev)) {
rc = gpio_request(MAHIMAHI_GPIO_BATTERY_CHARGER_CURRENT, "charger_current");
if (rc < 0) {
pr_err("%s: gpio_request(%d) failed: %d\n", __func__,
MAHIMAHI_GPIO_BATTERY_CHARGER_CURRENT, rc);
gpio_free(MAHIMAHI_GPIO_BATTERY_CHARGER_EN);
kfree(p);
return rc;
}
}
p->pdev.name = "ds2784-battery";
p->pdev.id = -1;
p->pdev.dev.platform_data = &p->pdata;
p->pdata.charge = ds2784_charge;
p->pdata.w1_slave = sl;
platform_device_register(&p->pdev);
return 0;
}
int bravo_get_rx_vol(uint8_t hw, int level)
{
int vol;
struct q6_hw_info *info;
if (level > 100)
level = 100;
else if (level < 0)
level = 0;
if (is_cdma_version(system_rev) && hw == Q6_HW_HANDSET) {
int handset_volume[6] = { -1600, -1300, -1000, -600, -300, 0 };
vol = handset_volume[5 * level / 100];
} else {
info = &q6_audio_hw[hw];
vol = info->min_gain + ((info->max_gain - info->min_gain) * level) / 100;
}
D("%s %d\n", __func__, vol);
return vol;
}
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 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());
}
