static void internal_phy_reset(void)
{
struct msm_rpc_endpoint *usb_ep;
int rc;
struct hsusb_phy_start_req {
struct rpc_request_hdr hdr;
} req;
printk(KERN_INFO "msm_hsusb_phy_reset\n");
usb_ep = msm_rpc_connect(HSUSB_API_PROG, HSUSB_API_VERS, 0);
if (IS_ERR(usb_ep)) {
printk(KERN_ERR "%s: init rpc failed! error: %ld\n",
__func__, PTR_ERR(usb_ep));
goto close;
}
rc = msm_rpc_call(usb_ep, HSUSB_API_INIT_PHY_PROC,
&req, sizeof(req), 5 * HZ);
if (rc < 0)
printk(KERN_ERR "%s: rpc call failed! (%d)\n", __func__, rc);
close:
msm_rpc_close(usb_ep);
}
static int
msmrtc_probe(struct platform_device *pdev)
{
struct rpcsvr_platform_device *rdev =
container_of(pdev, struct rpcsvr_platform_device, base);
ep = msm_rpc_connect(rdev->prog, rdev->vers, 0);
if (IS_ERR(ep)) {
printk(KERN_ERR "%s: init rpc failed! rc = %ld\n",
__func__, PTR_ERR(ep));
return PTR_ERR(ep);
}
rtc = rtc_device_register("msm_rtc",
&pdev->dev,
&msm_rtc_ops,
THIS_MODULE);
if (IS_ERR(rtc)) {
printk(KERN_ERR "%s: Can't register RTC device (%ld)\n",
pdev->name, PTR_ERR(rtc));
return PTR_ERR(rtc);
}
return 0;
}
static void set_pmic_vibrator(int on)
{
static struct msm_rpc_endpoint *vib_endpoint;
/* < DTS2012041806002 houming 20120504 begin*/
int ret=0;
/* DTS2012041806002 houming 20120504 end > */
struct set_vib_on_off_req {
struct rpc_request_hdr hdr;
/* < DTS2010080500080 luojianhong 201000817 begin*/
#ifndef CONFIG_HUAWEI_SETTING_TIMER_FOR_VIBRATOR_OFF
uint32_t data;
#else
uint32_t vib_volt;
uint32_t vib_time;//vibratting time pass to modem .
#endif
/* DTS2010080500080 luojianhong 201000817 end > */
} req;
if (!vib_endpoint) {
vib_endpoint = msm_rpc_connect(PM_LIBPROG, PM_LIBVERS, 0);
if (IS_ERR(vib_endpoint)) {
printk(KERN_ERR "init vib rpc failed!\n");
vib_endpoint = 0;
return;
}
}
/* < DTS2010080500080 luojianhong 201000817 begin*/
if (on)
{
#ifndef CONFIG_HUAWEI_SETTING_TIMER_FOR_VIBRATOR_OFF
req.data = cpu_to_be32(PMIC_VIBRATOR_LEVEL);
#else
req.vib_volt = cpu_to_be32(PMIC_VIBRATOR_LEVEL);
req.vib_time = cpu_to_be32(time_value);
#endif
}
else
{
#ifndef CONFIG_HUAWEI_SETTING_TIMER_FOR_VIBRATOR_OFF
req.data = cpu_to_be32(0);
#else
req.vib_volt = cpu_to_be32(0);
req.vib_time = cpu_to_be32(0);
#endif
}
/* DTS2010080500080 luojianhong 201000817 end > */
/*<BU5D07918, sibingsong 20100416 begin*/
#ifndef CONFIG_HUAWEI_FEATURE_VIBRATOR
/*BU5D07918, sibingsong 20100416 end>*/
msm_rpc_call(vib_endpoint, HTC_PROCEDURE_SET_VIB_ON_OFF, &req,
sizeof(req), 5 * HZ);
/*<BU5D07918, sibingsong 20100416 begin*/
#else
/* < DTS2012041806002 houming 20120504 begin*/
/* Add return value to determine */
ret=msm_rpc_call(vib_endpoint, HW_PROCEDURE_SET_VIB_ON_OFF, &req,
sizeof(req), 5 * HZ);
if(ret)
{
printk("%s:msm_rpc_call fail,ret=%d\n",__func__,ret);
}
/* DTS2012041806002 houming 20120504 end > */
#endif
/*BU5D07918, sibingsong 20100416 end>*/
}
static int htc_headset_pmic_probe(struct platform_device *pdev)
{
int ret = 0;
uint32_t vers = 0;
struct htc_headset_pmic_platform_data *pdata = pdev->dev.platform_data;
HS_LOG("++++++++++++++++++++");
hi = kzalloc(sizeof(struct htc_35mm_pmic_info), GFP_KERNEL);
if (!hi)
return -ENOMEM;
hi->pdata.driver_flag = pdata->driver_flag;
hi->pdata.hpin_gpio = pdata->hpin_gpio;
hi->pdata.hpin_irq = pdata->hpin_irq;
hi->pdata.key_gpio = pdata->key_gpio;
hi->pdata.key_irq = pdata->key_irq;
hi->pdata.key_enable_gpio = pdata->key_enable_gpio;
hi->pdata.hs_controller = pdata->hs_controller;
hi->pdata.hs_switch = pdata->hs_switch;
hi->pdata.adc_mic = pdata->adc_mic;
if (!hi->pdata.adc_mic)
hi->pdata.adc_mic = HS_DEF_MIC_ADC_16_BIT_MIN;
if (pdata->adc_mic_bias[0] && pdata->adc_mic_bias[1]) {
memcpy(hi->pdata.adc_mic_bias, pdata->adc_mic_bias,
sizeof(hi->pdata.adc_mic_bias));
hi->pdata.adc_mic = hi->pdata.adc_mic_bias[0];
} else {
hi->pdata.adc_mic_bias[0] = hi->pdata.adc_mic;
hi->pdata.adc_mic_bias[1] = HS_DEF_MIC_ADC_16_BIT_MAX;
}
if (pdata->adc_remote[5])
memcpy(hi->pdata.adc_remote, pdata->adc_remote,
sizeof(hi->pdata.adc_remote));
if (pdata->adc_metrico[0] && pdata->adc_metrico[1])
memcpy(hi->pdata.adc_metrico, pdata->adc_metrico,
sizeof(hi->pdata.adc_metrico));
hi->hpin_irq_type = IRQF_TRIGGER_LOW;
hi->hpin_debounce = HS_JIFFIES_ZERO;
hi->key_irq_type = IRQF_TRIGGER_LOW;
wake_lock_init(&hi->hs_wake_lock, WAKE_LOCK_SUSPEND, DRIVER_NAME);
detect_wq = create_workqueue("HS_PMIC_DETECT");
if (detect_wq == NULL) {
ret = -ENOMEM;
HS_ERR("Failed to create detect workqueue");
goto err_create_detect_work_queue;
}
button_wq = create_workqueue("HS_PMIC_BUTTON");
if (button_wq == NULL) {
ret = -ENOMEM;
HS_ERR("Failed to create button workqueue");
goto err_create_button_work_queue;
}
if (hi->pdata.hpin_gpio) {
ret = hs_pmic_request_irq(hi->pdata.hpin_gpio,
&hi->pdata.hpin_irq, detect_irq_handler,
hi->hpin_irq_type, "HS_PMIC_DETECT", 1);
if (ret < 0) {
HS_ERR("Failed to request PMIC HPIN IRQ (0x%X)", ret);
goto err_request_detect_irq;
}
}
if (hi->pdata.key_gpio) {
ret = hs_pmic_request_irq(hi->pdata.key_gpio,
&hi->pdata.key_irq, button_irq_handler,
hi->key_irq_type, "HS_PMIC_BUTTON", 1);
if (ret < 0) {
HS_ERR("Failed to request PMIC button IRQ (0x%X)", ret);
goto err_request_button_irq;
}
}
if (hi->pdata.driver_flag & DRIVER_HS_PMIC_RPC_KEY) {
/* Register ADC RPC client */
endpoint_adc = msm_rpc_connect(HS_RPC_CLIENT_PROG,
HS_RPC_CLIENT_VERS, 0);
if (IS_ERR(endpoint_adc)) {
hi->pdata.driver_flag &= ~DRIVER_HS_PMIC_RPC_KEY;
HS_LOG("Failed to register ADC RPC client");
} else
HS_LOG("Register ADC RPC client successfully");
}
if (hi->pdata.driver_flag & DRIVER_HS_PMIC_DYNAMIC_THRESHOLD) {
/* Register threshold RPC client */
vers = HS_PMIC_RPC_CLIENT_VERS_3_1;
endpoint_current = msm_rpc_connect_compatible(
HS_PMIC_RPC_CLIENT_PROG, vers, 0);
if (!endpoint_current) {
vers = HS_PMIC_RPC_CLIENT_VERS_2_1;
endpoint_current = msm_rpc_connect(
HS_PMIC_RPC_CLIENT_PROG, vers, 0);
}
if (!endpoint_current) {
vers = HS_PMIC_RPC_CLIENT_VERS_1_1;
endpoint_current = msm_rpc_connect(
HS_PMIC_RPC_CLIENT_PROG, vers, 0);
}
if (!endpoint_current) {
vers = HS_PMIC_RPC_CLIENT_VERS;
endpoint_current = msm_rpc_connect(
HS_PMIC_RPC_CLIENT_PROG, vers, 0);
}
if (IS_ERR(endpoint_current)) {
hi->pdata.driver_flag &=
~DRIVER_HS_PMIC_DYNAMIC_THRESHOLD;
HS_LOG("Failed to register threshold RPC client");
} else
HS_LOG("Register threshold RPC client successfully"
" (0x%X)", vers);
}
hs_pmic_register();
hs_notify_driver_ready(DRIVER_NAME);
HS_LOG("--------------------");
return 0;
err_request_button_irq:
if (hi->pdata.hpin_gpio) {
free_irq(hi->pdata.hpin_irq, 0);
gpio_free(hi->pdata.hpin_gpio);
}
err_request_detect_irq:
destroy_workqueue(button_wq);
err_create_button_work_queue:
destroy_workqueue(detect_wq);
err_create_detect_work_queue:
wake_lock_destroy(&hi->hs_wake_lock);
kfree(hi);
HS_ERR("Failed to register %s driver", DRIVER_NAME);
return ret;
}
static void set_pmic_vibrator(void)
{
static struct msm_rpc_endpoint *vib_endpoint;
struct pm_vib_mot_set_volt_args {
struct rpc_request_hdr hdr;
uint32_t data;
} req;
int rc;
unsigned long flags;
int kick_time;
if (!vib_endpoint) {
int i;
for (i = 0; i < ARRAY_SIZE(pm_rpc_versions); i++) {
vib_endpoint = msm_rpc_connect(PM_LIBPROG,
pm_rpc_versions[i], 0);
if (IS_ERR(vib_endpoint))
printk(KERN_INFO \
"init vib rpc version %d failed!\n", \
pm_rpc_versions[i]);
else
break;
}
}
if (IS_ERR(vib_endpoint)) {
printk(KERN_ERR "init vib rpc failed!\n");
vib_endpoint = 0;
return;
}
pr_debug("%s: ON=%d\n", __func__, vibe_state);
spin_lock_irqsave(&vibe_lock, flags);
switch (vibe_state) {
case TASK_KICK_START:
if (long_vibe_time > STRONG_VIBRATION_TIME) {
kick_time = STRONG_VIBRATION_TIME;
long_vibe_time -= STRONG_VIBRATION_TIME;
vibe_state = TASK_START;
} else {
kick_time = long_vibe_time;
vibe_state = TASK_STOP;
long_vibe_time = 0;
}
req.data = cpu_to_be32(VIBRATOR_LEVEL_STRONG);
hrtimer_start(&vibe_timer,
ktime_set(kick_time / 1000,
(kick_time % 1000) * 1000000), HRTIMER_MODE_REL);
pr_debug("%s: KICK START for %d ms\n", __func__, kick_time);
break;
case TASK_START:
req.data = cpu_to_be32(PM_VIBRATOR_LEVEL);
pr_debug("%s: START for %d ms\n", __func__, long_vibe_time);
hrtimer_start(&vibe_timer,
ktime_set((long_vibe_time) / 1000,
((long_vibe_time) % 1000) * 1000000), HRTIMER_MODE_REL);
long_vibe_time = 0;
vibe_state = TASK_STOP;
break;
case TASK_STOP:
case TASK_FORCE_STOP:
default:
vibe_state = TASK_NONE;
req.data = cpu_to_be32(0);
}
spin_unlock_irqrestore(&vibe_lock, flags);
rc = msm_rpc_call(vib_endpoint, PM_VIB_MOT_SET_VOLT_PROC, &req,
sizeof(req), 5 * HZ);
if (rc)
printk(KERN_ERR "vib rpc failed! rc=%d\n", rc);
}
static int htc_headset_pmic_probe(struct platform_device *pdev)
{
int ret = 0;
uint32_t vers = 0;
struct htc_headset_pmic_platform_data *pdata = pdev->dev.platform_data;
HS_LOG("++++++++++++++++++++");
pmic_info = kzalloc(sizeof(struct htc_35mm_pmic_info), GFP_KERNEL);
if (!pmic_info)
return -ENOMEM;
pmic_info->pdata.driver_flag = pdata->driver_flag;
pmic_info->pdata.hpin_gpio = pdata->hpin_gpio;
pmic_info->pdata.hpin_irq = pdata->hpin_irq;
pmic_info->pdata.key_enable_gpio = pdata->key_enable_gpio;
pmic_info->pdata.hs_controller = pdata->hs_controller;
pmic_info->pdata.hs_switch = pdata->hs_switch;
pmic_info->pdata.adc_mic = pdata->adc_mic;
if (!pmic_info->pdata.adc_mic)
pmic_info->pdata.adc_mic = HS_DEF_MIC_ADC_16_BIT;
if (pdata->adc_remote[5])
memcpy(pmic_info->pdata.adc_remote, pdata->adc_remote,
sizeof(pmic_info->pdata.adc_remote));
if (pdata->adc_metrico[0] && pdata->adc_metrico[1])
memcpy(pmic_info->pdata.adc_metrico, pdata->adc_metrico,
sizeof(pmic_info->pdata.adc_metrico));
pmic_info->hpin_irq_type = IRQF_TRIGGER_LOW;
pmic_info->hpin_debounce = HS_JIFFIES_INSERT;
wake_lock_init(&pmic_info->hs_wake_lock, WAKE_LOCK_SUSPEND,
DRIVER_NAME);
detect_wq = create_workqueue("detection");
if (detect_wq == NULL) {
ret = -ENOMEM;
goto err_create_detect_work_queue;
}
if (pmic_info->pdata.hpin_irq) {
ret = request_irq(pmic_info->pdata.hpin_irq, htc_35mm_pmic_irq,
pmic_info->hpin_irq_type, "HS_PMIC_DETECT",
NULL);
if (ret < 0) {
HS_LOG("Failed to request PMIC HPIN IRQ (0x%X)", ret);
goto err_request_detect_irq;
}
ret = set_irq_wake(pmic_info->pdata.hpin_irq, 1);
if (ret < 0)
HS_LOG("Failed to set PMIC HPIN IRQ wake");
}
if (pmic_info->pdata.driver_flag & DRIVER_HS_PMIC_RPC_KEY) {
/* Register ADC RPC client */
endpoint_adc = msm_rpc_connect(HS_RPC_CLIENT_PROG,
HS_RPC_CLIENT_VERS, 0);
if (IS_ERR(endpoint_adc)) {
pmic_info->pdata.driver_flag &= ~DRIVER_HS_PMIC_RPC_KEY;
HS_LOG("Failed to register ADC RPC client");
} else
HS_LOG("Register ADC RPC client successfully");
}
if (pmic_info->pdata.driver_flag & DRIVER_HS_PMIC_DYNAMIC_THRESHOLD) {
/* Register threshold RPC client */
vers = HS_PMIC_RPC_CLIENT_VERS_3_1;
endpoint_current = msm_rpc_connect_compatible(
HS_PMIC_RPC_CLIENT_PROG, vers, 0);
if (!endpoint_current) {
vers = HS_PMIC_RPC_CLIENT_VERS_2_1;
endpoint_current = msm_rpc_connect(
HS_PMIC_RPC_CLIENT_PROG, vers, 0);
}
if (!endpoint_current) {
vers = HS_PMIC_RPC_CLIENT_VERS_1_1;
endpoint_current = msm_rpc_connect(
HS_PMIC_RPC_CLIENT_PROG, vers, 0);
}
if (!endpoint_current) {
vers = HS_PMIC_RPC_CLIENT_VERS;
endpoint_current = msm_rpc_connect(
HS_PMIC_RPC_CLIENT_PROG, vers, 0);
}
if (IS_ERR(endpoint_current)) {
pmic_info->pdata.driver_flag &=
~DRIVER_HS_PMIC_DYNAMIC_THRESHOLD;
HS_LOG("Failed to register threshold RPC client");
} else
HS_LOG("Register threshold RPC client successfully"
" (0x%X)", vers);
}
hs_pmic_register();
hs_notify_driver_ready(DRIVER_NAME);
HS_LOG("--------------------");
return 0;
err_request_detect_irq:
destroy_workqueue(detect_wq);
err_create_detect_work_queue:
wake_lock_destroy(&pmic_info->hs_wake_lock);
kfree(pmic_info);
HS_LOG("Failed to register %s driver", DRIVER_NAME);
return ret;
}
