static int __init hs_rpc_cb_init(void)
{
int rc = 0;
/* version 2 is used in 7x30 */
rpc_client = msm_rpc_register_client("hs",
HS_RPC_PROG, HS_RPC_VERS_2, 0, hs_cb_func);
if (IS_ERR(rpc_client)) {
pr_err("%s: couldn't open rpc client with version 2 err %ld\n",
__func__, PTR_ERR(rpc_client));
/*version 1 is used in 7x27, 8x50 */
rpc_client = msm_rpc_register_client("hs",
HS_RPC_PROG, HS_RPC_VERS_1, 0, hs_cb_func);
}
if (IS_ERR(rpc_client)) {
pr_err("%s: couldn't open rpc client with version 1 err %ld\n",
__func__, PTR_ERR(rpc_client));
return PTR_ERR(rpc_client);
}
rc = msm_rpc_client_req(rpc_client, HS_SUBSCRIBE_SRVC_PROC,
hs_rpc_register_subs_arg, NULL,
hs_rpc_register_subs_res, NULL, -1);
if (rc) {
pr_err("%s: couldn't send rpc client request\n", __func__);
msm_rpc_unregister_client(rpc_client);
}
return rc;
}
int msm_pm_app_rpc_init(void)
{
#if 1
/* allow qsd8650 */
#else
if (!machine_is_qsd8x50_ffa() && !machine_is_msm7x27_ffa())
return -ENOTSUPP;
#endif
boost_vreg = vreg_get(NULL, "boost");
if (IS_ERR(boost_vreg)) {
pr_err("%s: boost vreg get failed\n", __func__);
return PTR_ERR(boost_vreg);
}
usb_vreg = vreg_get(NULL, "usb");
if (IS_ERR(usb_vreg)) {
pr_err("%s: usb vreg get failed\n", __func__);
vreg_put(usb_vreg);
return PTR_ERR(usb_vreg);
}
client = msm_rpc_register_client("pmapp_usb",
PM_APP_USB_PROG,
PM_APP_USB_VERS_2_1, 1,
pm_app_usb_cb_func);
if (!IS_ERR(client)) {
rpc_pmapp_init_rpc_ids(PM_APP_USB_VERS_2_1);
goto done;
}
client = msm_rpc_register_client("pmapp_usb",
PM_APP_USB_PROG,
PM_APP_USB_VERS_1_2, 1,
pm_app_usb_cb_func);
if (!IS_ERR(client)) {
rpc_pmapp_init_rpc_ids(PM_APP_USB_VERS_1_2);
goto done;
}
client = msm_rpc_register_client("pmapp_usb",
PM_APP_USB_PROG,
PM_APP_USB_VERS_1_1, 1,
pm_app_usb_cb_func);
if (!IS_ERR(client))
rpc_pmapp_init_rpc_ids(PM_APP_USB_VERS_1_1);
else
return PTR_ERR(client);
done:
return 0;
}
struct msm_rpc_client *msm_pm_vbatt_init_client(
char *name,
u32 create_thread,
int (*cb_func)(struct msm_rpc_client *, void *, int),
u32 *version)
{
int i;
struct msm_rpc_client *clnt;
for (i = 0; i < ARRAY_SIZE(battery_valid_rpc_vers); i++) {
clnt = msm_rpc_register_client(name,
BATTERY_RPC_PROG,
battery_valid_rpc_vers[i],
create_thread,
cb_func);
if (NULL == clnt) {
pr_err("%s: FAIL: rpc_register_client. batt_client=NULL\n",
__func__);
return NULL;
} else if (IS_ERR(clnt))
continue;
else {
if (NULL != version)
*version = battery_valid_rpc_vers[i];
break;
}
}
if (IS_ERR(clnt))
clnt = NULL;
return clnt;
}
static int __devinit dev_dct_probe(struct platform_device *pdev)
{
int ret = 0;
hw_dev_rpc_client =
msm_rpc_register_client("dev_dct", BATTERY_RPC_PROG,
BATTERY_RPC_VER_2_1,
1, NULL);
if ( NULL == hw_dev_rpc_client )
{
printk("%s: FAIL: rpc_register_client. hw_dev_rpc_client=NULL\n",
__func__);
return -ENODEV;
}
ret = hw_rpc_set_dev_flag();
if( ret < 0 )
{
printk("%s: set hw dev detect flag failed.\n", __func__ );
}
return 0;
}
int msm_pm_app_rpc_init(void (*callback)(int online))
{
uint32_t cb_id, rc;
if (!machine_is_qsd8x50_ffa() && !machine_is_qsd8x50a_ffa()
&& !machine_is_msm7x27_ffa())
return -ENOTSUPP;
client = msm_rpc_register_client("pmapp_usb",
PMAPP_RPC_PROG,
PMAPP_RPC_VER_2_1, 1,
pm_app_usb_cb_func);
if (!IS_ERR(client)) {
rpc_pmapp_init_rpc_ids(PMAPP_RPC_VER_2_1);
goto done;
}
client = msm_rpc_register_client("pmapp_usb",
PMAPP_RPC_PROG,
PMAPP_RPC_VER_1_2, 1,
pm_app_usb_cb_func);
if (!IS_ERR(client)) {
rpc_pmapp_init_rpc_ids(PMAPP_RPC_VER_1_2);
goto done;
}
client = msm_rpc_register_client("pmapp_usb",
PMAPP_RPC_PROG,
PMAPP_RPC_VER_1_1, 1,
pm_app_usb_cb_func);
if (!IS_ERR(client))
rpc_pmapp_init_rpc_ids(PMAPP_RPC_VER_1_1);
else
return PTR_ERR(client);
done:
cb_id = msm_rpc_add_cb_func(client, (void *)callback);
/* In case of NULL callback funtion, cb_id would be -1 */
if ((int) cb_id < -1)
return cb_id;
rc = msm_rpc_client_req(client,
rpc_ids.reg_for_vbus_valid,
vbus_sess_valid_arg_cb,
&cb_id, NULL, NULL, -1);
return rc;
}
int __devinit msm_lightsensor_init_rpc(void)
{
int rc = 0;
light_client =
msm_rpc_register_client("lightsensor", LIGHTSENSOR_RPC_PROG,
BATTERY_RPC_VER_4_1,
1, msm_lightsensor_cb_func);
if (light_client == NULL) {
pr_err("%s: FAIL: rpc_register_client. light_client=NULL\n",
__func__);
return -ENODEV;
} else if (IS_ERR(light_client)) {
light_client =
msm_rpc_register_client("lightsensor", LIGHTSENSOR_RPC_PROG,
BATTERY_RPC_VER_1_1,
1, msm_lightsensor_cb_func);
batt_api_version = BATTERY_RPC_VER_1_1;
} else {
light_client =
msm_rpc_register_client("lightsensor", LIGHTSENSOR_RPC_PROG,
BATTERY_RPC_VER_2_1,
1, msm_lightsensor_cb_func);
batt_api_version = BATTERY_RPC_VER_2_1;
}
if (IS_ERR(light_client)) {
light_client=
msm_rpc_register_client("lightsensor", LIGHTSENSOR_RPC_PROG,
BATTERY_RPC_VER_5_1,
1, msm_lightsensor_cb_func);
batt_api_version = BATTERY_RPC_VER_5_1;
}
if (IS_ERR(light_client)) {
rc = PTR_ERR(light_client);
pr_err("%s: ERROR: rpc_register_client: rc = %d\n ",
__func__, rc);
light_client = NULL;
return rc;
}
return rc;
}
int msm_ear_init_rpc(void)
{
int rc = 0;
ear_client =
msm_rpc_register_client("sec_jack", EAR_RPC_PROG,
BATTERY_RPC_VER_2_1,
1, msm_ear_cb_func);
if (ear_client == NULL) {
pr_err("%s: FAIL: rpc_register_client. ear_client=NULL\n",
__func__);
return -ENODEV;
} else if (IS_ERR(ear_client)) {
ear_client =
msm_rpc_register_client("sec_jack", EAR_RPC_PROG,
BATTERY_RPC_VER_1_1,
1, msm_ear_cb_func);
ear_batt_api_version = BATTERY_RPC_VER_1_1;
} else
ear_batt_api_version = BATTERY_RPC_VER_2_1;
if (IS_ERR(ear_client)) {
ear_client =
msm_rpc_register_client("sec_jack", EAR_RPC_PROG,
BATTERY_RPC_VER_5_1,
1, msm_ear_cb_func);
ear_batt_api_version = BATTERY_RPC_VER_5_1;
}
if (IS_ERR(ear_client)) {
rc = PTR_ERR(ear_client);
pr_err("%s: ERROR: rpc_register_client: rc = %d\n ",
__func__, rc);
ear_client = NULL;
return rc;
}
return rc;
}
static struct msm_rpc_client *ping_mdm_init(void)
{
mutex_lock(&ping_mdm_lock);
if (open_count == 0) {
rpc_client = msm_rpc_register_client("pingdef",
PING_MDM_PROG,
PING_MDM_VERS, 1,
ping_mdm_cb_func);
if (!IS_ERR(rpc_client))
open_count++;
}
mutex_unlock(&ping_mdm_lock);
return rpc_client;
}
struct msm_rpc_client *oem_rapi_client_init(void)
{
mutex_lock(&oem_rapi_client_lock);
if (open_count == 0) {
rpc_client = msm_rpc_register_client("oemrapiclient",
OEM_RAPI_PROG,
OEM_RAPI_VERS, 0,
oem_rapi_client_cb);
if (!IS_ERR(rpc_client))
open_count++;
}
mutex_unlock(&oem_rapi_client_lock);
return rpc_client;
}
static int audio_open(struct inode *inode, struct file *file)
{
struct audio *audio = &the_audio;
int rc, cnt;
mutex_lock(&audio->lock);
if (audio->opened) {
MM_ERR("busy as driver already in open state\n");
rc = -EBUSY;
goto done;
}
if (!audio->data) {
audio->data = kmalloc(BUFSZ, GFP_KERNEL);
if (!audio->data) {
MM_ERR("could not allocate buffers\n");
rc = -ENOMEM;
goto done;
}
}
audio->client = msm_rpc_register_client("voice_pcm_interface_client",
SND_VOC_PCM_INTERFACE_PROG,
SND_VOC_PCM_INTERFACE_VERS, 1,
pcm_interface_process_callback_routine);
if (IS_ERR(audio->client)) {
MM_ERR("Failed to register voice pcm interface client"\
"to 0x%8x\n", SND_VOC_PCM_INTERFACE_PROG);
kfree(audio->data);
audio->data = NULL;
rc = -ENODEV;
goto done;
}
MM_INFO("voice pcm client registred %p\n", audio->client);
for (cnt = 0; cnt < MAX_VOC_FRAMES; cnt++) {
audio->out[cnt].data = (audio->data +\
((MAX_VOC_FRAME_SIZE * 2) * cnt));
audio->out[cnt].size = MAX_VOC_FRAME_SIZE * 2;
MM_DBG("data ptr = %p\n", audio->out[cnt].data);
}
file->private_data = audio;
audio_flush(audio);
audio->opened = 1;
rc = 0;
done:
mutex_unlock(&audio->lock);
return rc;
}
int msm_fsusb_rpc_init(struct msm_otg_ops *ops)
{
host_ops = ops;
client = msm_rpc_register_client("fsusb",
PM_APP_OTG_PROG,
PM_APP_OTG_VERS, 1,
msm_fsusb_cb_func);
if (IS_ERR(client)) {
pr_err("%s: couldn't open rpc client\n", __func__);
return PTR_ERR(client);
}
return 0;
}
static int __init hs_rpc_cb_init(void)
{
int rc = 0, i, num_vers;
num_vers = ARRAY_SIZE(rpc_vers);
for (i = 0; i < num_vers; i++) {
rpc_client = msm_rpc_register_client("hs",
HS_RPC_PROG, rpc_vers[i], 0, hs_cb_func);
if (IS_ERR(rpc_client))
pr_debug("%s: RPC Client version %d failed, fallback\n",
__func__, rpc_vers[i]);
else
break;
}
if (IS_ERR(rpc_client)) {
pr_err("%s: Incompatible RPC version error %ld\n",
__func__, PTR_ERR(rpc_client));
return PTR_ERR(rpc_client);
}
rc = msm_rpc_client_req(rpc_client, HS_SUBSCRIBE_SRVC_PROC,
hs_rpc_register_subs_arg, NULL,
hs_rpc_register_subs_res, NULL, -1);
if (rc) {
pr_err("%s: RPC client request failed for subscribe services\n",
__func__);
goto err_client_req;
}
#if 0
rc = msm_rpc_client_req(rpc_client, HS_PROCESS_CMD_PROC,
hs_rpc_pwr_cmd_arg, NULL,
hs_rpc_pwr_cmd_res, NULL, -1);
if (rc)
pr_err("%s: RPC client request failed for pwr key"
" delay cmd, using normal mode\n", __func__);
#endif
return 0;
err_client_req:
msm_rpc_unregister_client(rpc_client);
return rc;
}
static int __init hs_rpc_cb_init(void)
{
int rc = 0;
rpc_client = msm_rpc_register_client("hs",
HS_RPC_PROG, HS_RPC_VERS, 0, hs_cb_func);
if (IS_ERR(rpc_client)) {
pr_err("%s: couldn't open rpc client err %ld\n", __func__,
PTR_ERR(rpc_client));
return PTR_ERR(rpc_client);
}
rc = msm_rpc_client_req(rpc_client, HS_SUBSCRIBE_SRVC_PROC,
hs_rpc_register_subs_arg, NULL,
hs_rpc_register_subs_res, NULL, -1);
if (rc) {
pr_err("%s: couldn't send rpc client request\n", __func__);
msm_rpc_unregister_client(rpc_client);
}
return rc;
}
/* Returns : client id on success
* and -1 on failure
*/
int adie_svc_get(void)
{
int id, rc = 0;
struct adie_svc_client_register_cb_args arg;
mutex_lock(&adie_client_lock);
for (id = 0; id < ADIE_SVC_MAX_CLIENTS; id++) {
if (adie_client[id].client_id == -1 &&
adie_client[id].rpc_client == NULL)
break;
}
if (id == ADIE_SVC_MAX_CLIENTS) {
mutex_unlock(&adie_client_lock);
return -1;
}
mutex_lock(&adie_client[id].lock);
adie_client[id].rpc_client = msm_rpc_register_client("adie_client",
ADIE_SVC_PROG,
ADIE_SVC_VERS, 1,
adie_svc_rpc_cb_func);
if (IS_ERR(adie_client[id].rpc_client)) {
MM_ERR("Failed to register RPC client\n");
adie_client[id].rpc_client = NULL;
mutex_unlock(&adie_client[id].lock);
mutex_unlock(&adie_client_lock);
return -1;
}
mutex_unlock(&adie_client_lock);
adie_client[id].adie_svc_cb_done = 0;
arg.cb_id = id;
adie_client[id].cb_id = arg.cb_id;
mutex_unlock(&adie_client[id].lock);
rc = msm_rpc_client_req(adie_client[id].rpc_client,
SND_ADIE_SVC_CLIENT_REGISTER_PROC,
adie_svc_client_register_arg, &arg,
NULL, NULL, -1);
if (!rc) {
rc = wait_event_interruptible(adie_client[id].wq,
adie_client[id].adie_svc_cb_done);
mutex_lock(&adie_client[id].lock);
if (unlikely(rc < 0)) {
if (rc == -ERESTARTSYS)
MM_ERR("wait_event_interruptible "
"returned -ERESTARTSYS\n");
else
MM_ERR("wait_event_interruptible "
"returned error\n");
rc = -1;
goto err;
}
MM_DBG("Status %d received from CB function, id %d rc %d\n",
adie_client[id].status, adie_client[id].client_id, rc);
rc = id;
if (adie_client[id].status == ADIE_SVC_STATUS_FAILURE) {
MM_ERR("Received failed status for register request\n");
rc = -1;
} else
goto done;
} else {
MM_ERR("Failed to send register client request\n");
rc = -1;
mutex_lock(&adie_client[id].lock);
}
err:
msm_rpc_unregister_client(adie_client[id].rpc_client);
adie_client[id].rpc_client = NULL;
adie_client[id].client_id = -1;
adie_client[id].cb_id = MSM_RPC_CLIENT_NULL_CB_ID;
adie_client[id].adie_svc_cb_done = 0;
done:
mutex_unlock(&adie_client[id].lock);
return rc;
}
static int __devinit
msmrtc_probe(struct platform_device *pdev)
{
int rc;
struct msm_rtc *rtc_pdata = NULL;
struct rpcsvr_platform_device *rdev =
container_of(pdev, struct rpcsvr_platform_device, base);
uint32_t prog_version;
#if defined(CONFIG_MACH_ACER_A4) || defined(CONFIG_MACH_ACER_A5)
struct rtc_time tm;
#endif
if (pdev->id == (TIMEREMOTE_PROG_VER_1 & RPC_VERSION_MAJOR_MASK))
prog_version = TIMEREMOTE_PROG_VER_1;
else if (pdev->id == (TIMEREMOTE_PROG_VER_2 &
RPC_VERSION_MAJOR_MASK))
prog_version = TIMEREMOTE_PROG_VER_2;
else
return -EINVAL;
rtc_pdata = kzalloc(sizeof(*rtc_pdata), GFP_KERNEL);
if (rtc_pdata == NULL) {
dev_err(&pdev->dev,
"%s: Unable to allocate memory\n", __func__);
return -ENOMEM;
}
rtc_pdata->rpc_client = msm_rpc_register_client("rtc", rdev->prog,
prog_version, 1, msmrtc_cb_func);
if (IS_ERR(rtc_pdata->rpc_client)) {
dev_err(&pdev->dev,
"%s: init RPC failed! VERS = %x\n", __func__,
prog_version);
rc = PTR_ERR(rtc_pdata->rpc_client);
kfree(rtc_pdata);
return rc;
}
/*
* Set up the callback client.
* For older targets this initialization will fail
*/
rc = msmrtc_setup_cb(rtc_pdata);
if (rc)
dev_dbg(&pdev->dev, "%s: Could not initialize RPC callback\n",
__func__);
rtc_pdata->rtcalarm_time = 0;
platform_set_drvdata(pdev, rtc_pdata);
#if defined(CONFIG_MACH_ACER_A4) || defined(CONFIG_MACH_ACER_A5)
/* Set the default system time to 2011-03-01 00:00:00 UTC.
*/
msmrtc_timeremote_read_time(&pdev->dev, &tm);
if (tm.tm_year < 90) {
tm.tm_year = 111; /* RTC layer expects years to start at 1900 */
tm.tm_mon = 2; /* RTC layer expects mons to be 0 based */
tm.tm_mday = 1;
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
tm.tm_wday = 1; /* 2011-03-01 is Tuesday */
msmrtc_timeremote_set_time(&pdev->dev, &tm);
}
#endif
rtc_pdata->rtc = rtc_device_register("msm_rtc",
&pdev->dev,
&msm_rtc_ops,
THIS_MODULE);
if (IS_ERR(rtc_pdata->rtc)) {
dev_err(&pdev->dev, "%s: Can't register RTC device (%ld)\n",
pdev->name, PTR_ERR(rtc_pdata->rtc));
rc = PTR_ERR(rtc_pdata->rtc);
goto fail_cb_setup;
}
#ifdef CONFIG_RTC_SECURE_TIME_SUPPORT
rtc_pdata->rtcsecure = rtc_device_register("msm_rtc_secure",
&pdev->dev,
&msm_rtc_ops_secure,
THIS_MODULE);
if (IS_ERR(rtc_pdata->rtcsecure)) {
dev_err(&pdev->dev,
"%s: Can't register RTC Secure device (%ld)\n",
pdev->name, PTR_ERR(rtc_pdata->rtcsecure));
rtc_device_unregister(rtc_pdata->rtc);
rc = PTR_ERR(rtc_pdata->rtcsecure);
goto fail_cb_setup;
}
#endif
#ifdef CONFIG_RTC_ASYNC_MODEM_SUPPORT
rtc_hctosys();
#endif
return 0;
fail_cb_setup:
msm_rpc_unregister_client(rtc_pdata->rpc_client);
kfree(rtc_pdata);
return rc;
}
static int __devinit tricolor_led_probe(struct platform_device *pdev)
{
const struct led_platform_data *pdata = pdev->dev.platform_data;
struct msm_rpc_client *rpc_client;
struct led_info *curr_led;
struct tricolor_led_data *led, *tmp_led;
int rc, i, j;
if (!pdata) {
dev_err(&pdev->dev, "platform data not supplied\n");
return -EINVAL;
}
/* initialize rpc client */
rpc_client = msm_rpc_register_client("led", LED_RPC_PROG,
LED_RPC_VER, 0, led_cb_func);
rc = IS_ERR(rpc_client);
if (rc) {
dev_err(&pdev->dev, "failed to initialize rpc_client\n");
return -EINVAL;
}
/* subscribe */
rc = msm_rpc_client_req(rpc_client, LED_SUBSCRIBE_PROC,
led_rpc_register_subs_arg, NULL,
led_rpc_res, NULL, -1);
if (rc) {
pr_err("%s: RPC client request failed for subscribe services\n",
__func__);
goto fail_mem_alloc;
}
led = devm_kzalloc(&pdev->dev, pdata->num_leds * sizeof(*led),
GFP_KERNEL);
if (!led) {
dev_err(&pdev->dev, "failed to alloc memory\n");
rc = -ENOMEM;
goto fail_mem_alloc;
}
for (i = 0; i < pdata->num_leds; i++) {
curr_led = &pdata->leds[i];
tmp_led = &led[i];
tmp_led->cdev.name = curr_led->name;
tmp_led->cdev.default_trigger = curr_led->default_trigger;
tmp_led->cdev.brightness_set = tricolor_led_set;
tmp_led->cdev.brightness_get = tricolor_led_get;
tmp_led->cdev.brightness = LED_OFF;
tmp_led->cdev.max_brightness = LED_FULL;
tmp_led->color = curr_led->flags;
tmp_led->rpc_client = rpc_client;
tmp_led->blink_status = false;
mutex_init(&tmp_led->lock);
rc = led_classdev_register(&pdev->dev, &tmp_led->cdev);
if (rc) {
dev_err(&pdev->dev, "failed to register led %s(%d)\n",
tmp_led->cdev.name, rc);
goto fail_led_reg;
}
/* Add blink attributes */
rc = device_create_file(tmp_led->cdev.dev, &dev_attr_blink);
if (rc) {
dev_err(&pdev->dev, "failed to create blink attr\n");
goto fail_blink_attr;
}
dev_set_drvdata(tmp_led->cdev.dev, tmp_led);
}
platform_set_drvdata(pdev, led);
return 0;
fail_blink_attr:
j = i;
while (j)
device_remove_file(led[--j].cdev.dev, &dev_attr_blink);
i++;
fail_led_reg:
while (i) {
led_classdev_unregister(&led[--i].cdev);
mutex_destroy(&led[i].lock);
}
fail_mem_alloc:
msm_rpc_unregister_client(rpc_client);
return rc;
}
static int
msmrtc_probe(struct platform_device *pdev)
{
int rc;
struct rpcsvr_platform_device *rdev =
container_of(pdev, struct rpcsvr_platform_device, base);
uint32_t prog_version;
if (pdev->id == (TIMEREMOTE_PROG_VER_1 & RPC_VERSION_MAJOR_MASK))
prog_version = TIMEREMOTE_PROG_VER_1;
else if (pdev->id == (TIMEREMOTE_PROG_VER_2 &
RPC_VERSION_MAJOR_MASK))
prog_version = TIMEREMOTE_PROG_VER_2;
else
return -EINVAL;
rpc_client = msm_rpc_register_client("rtc", rdev->prog,
prog_version, 1, msmrtc_cb_func);
if (IS_ERR(rpc_client)) {
pr_err("%s: init RPC failed! VERS = %x\n", __func__,
prog_version);
return PTR_ERR(rpc_client);
}
/*
* Set up the callback client.
* For older targets this initialization will fail
*/
rc = msmrtc_setup_cb();
if (rc)
pr_debug("%s: Could not initialize RPC callback\n",
__func__);
rtc = rtc_device_register("msm_rtc",
&pdev->dev,
&msm_rtc_ops,
THIS_MODULE);
if (IS_ERR(rtc)) {
pr_err("%s: Can't register RTC device (%ld)\n",
pdev->name, PTR_ERR(rtc));
rc = PTR_ERR(rtc);
goto fail_cb_setup;
}
#ifdef CONFIG_RTC_SECURE_TIME_SUPPORT
rtcsecure = rtc_device_register("msm_rtc_secure",
&pdev->dev,
&msm_rtc_ops_secure,
THIS_MODULE);
if (IS_ERR(rtcsecure)) {
pr_err("%s: Can't register RTC Secure device (%ld)\n",
pdev->name, PTR_ERR(rtcsecure));
rtc_device_unregister(rtc);
rc = PTR_ERR(rtcsecure);
goto fail_cb_setup;
}
#endif
#ifdef CONFIG_RTC_ASYNC_MODEM_SUPPORT
rtc_hctosys();
#endif
return 0;
fail_cb_setup:
msm_rpc_unregister_client(rpc_client);
return rc;
}
static int
msmrtc_probe(struct platform_device *pdev)
{
int rc;
struct rpcsvr_platform_device *rdev =
container_of(pdev, struct rpcsvr_platform_device, base);
uint32_t prog_version;
#ifdef CONFIG_MACH_ACER_A4
struct rtc_time tm;
#endif
if (pdev->id == (TIMEREMOTE_PROG_VER_1 & RPC_VERSION_MAJOR_MASK))
prog_version = TIMEREMOTE_PROG_VER_1;
else if (pdev->id == (TIMEREMOTE_PROG_VER_2 &
RPC_VERSION_MAJOR_MASK))
prog_version = TIMEREMOTE_PROG_VER_2;
else
return -EINVAL;
rpc_client = msm_rpc_register_client("rtc", rdev->prog,
prog_version, 1, msmrtc_cb_func);
if (IS_ERR(rpc_client)) {
pr_err("%s: init RPC failed! VERS = %x\n", __func__,
prog_version);
return PTR_ERR(rpc_client);
}
#ifdef CONFIG_MACH_ACER_A4
/* Set the default system time to 2010-10-01 00:00:00 UTC.
*/
msmrtc_timeremote_read_time(&pdev->dev, &tm);
if (tm.tm_year < 90) {
tm.tm_year = 110; /* RTC layer expects years to start at 1900 */
tm.tm_mon = 9; /* RTC layer expects mons to be 0 based */
tm.tm_mday = 1;
tm.tm_hour = 0;
tm.tm_min = 0;
tm.tm_sec = 0;
tm.tm_wday = 4; /* 2010-10-01 is Fri. */
msmrtc_timeremote_set_time(&pdev->dev, &tm);
}
#endif
/*
* Set up the callback client.
* For older targets this initialization will fail
*/
rc = msmrtc_setup_cb();
if (rc)
pr_debug("%s: Could not initialize RPC callback\n",
__func__);
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));
rc = PTR_ERR(rtc);
goto fail_cb_setup;
}
#ifdef CONFIG_RTC_SECURE_TIME_SUPPORT
rtcsecure = rtc_device_register("msm_rtc_secure",
&pdev->dev,
&msm_rtc_ops_secure,
THIS_MODULE);
if (IS_ERR(rtcsecure)) {
printk(KERN_ERR "%s: Can't register RTC Secure device (%ld)\n",
pdev->name, PTR_ERR(rtcsecure));
rtc_device_unregister(rtc);
rc = PTR_ERR(rtcsecure);
goto fail_cb_setup;
}
#endif
return 0;
fail_cb_setup:
msm_rpc_unregister_client(rpc_client);
return rc;
}
static int __devinit
msmrtc_probe(struct platform_device *pdev)
{
int rc;
struct msm_rtc *rtc_pdata = NULL;
struct rpcsvr_platform_device *rdev =
container_of(pdev, struct rpcsvr_platform_device, base);
uint32_t prog_version;
if (pdev->id == (TIMEREMOTE_PROG_VER_1 & RPC_VERSION_MAJOR_MASK))
prog_version = TIMEREMOTE_PROG_VER_1;
else if (pdev->id == (TIMEREMOTE_PROG_VER_2 &
RPC_VERSION_MAJOR_MASK))
prog_version = TIMEREMOTE_PROG_VER_2;
else
return -EINVAL;
rtc_pdata = kzalloc(sizeof(*rtc_pdata), GFP_KERNEL);
if (rtc_pdata == NULL) {
dev_err(&pdev->dev,
"%s: Unable to allocate memory\n", __func__);
return -ENOMEM;
}
rtc_pdata->rpc_client = msm_rpc_register_client("rtc", rdev->prog,
prog_version, 1, msmrtc_cb_func);
if (IS_ERR(rtc_pdata->rpc_client)) {
dev_err(&pdev->dev,
"%s: init RPC failed! VERS = %x\n", __func__,
prog_version);
rc = PTR_ERR(rtc_pdata->rpc_client);
kfree(rtc_pdata);
return rc;
}
/*< DTS2011052803245 wangjiongfeng 20110531 begin */
huawei_alarm_client = rtc_pdata->rpc_client;
/* DTS2011052803245 wangjiongfeng 20110531 end >*/
/*
* Set up the callback client.
* For older targets this initialization will fail
*/
rc = msmrtc_setup_cb(rtc_pdata);
if (rc)
dev_dbg(&pdev->dev, "%s: Could not initialize RPC callback\n",
__func__);
rtc_pdata->rtcalarm_time = 0;
platform_set_drvdata(pdev, rtc_pdata);
rtc_pdata->rtc = rtc_device_register("msm_rtc",
&pdev->dev,
&msm_rtc_ops,
THIS_MODULE);
if (IS_ERR(rtc_pdata->rtc)) {
dev_err(&pdev->dev, "%s: Can't register RTC device (%ld)\n",
pdev->name, PTR_ERR(rtc_pdata->rtc));
rc = PTR_ERR(rtc_pdata->rtc);
goto fail_cb_setup;
}
#ifdef CONFIG_RTC_SECURE_TIME_SUPPORT
rtc_pdata->rtcsecure = rtc_device_register("msm_rtc_secure",
&pdev->dev,
&msm_rtc_ops_secure,
THIS_MODULE);
if (IS_ERR(rtc_pdata->rtcsecure)) {
dev_err(&pdev->dev,
"%s: Can't register RTC Secure device (%ld)\n",
pdev->name, PTR_ERR(rtc_pdata->rtcsecure));
rtc_device_unregister(rtc_pdata->rtc);
rc = PTR_ERR(rtc_pdata->rtcsecure);
goto fail_cb_setup;
}
#endif
#ifdef CONFIG_RTC_ASYNC_MODEM_SUPPORT
rtc_hctosys();
#endif
return 0;
fail_cb_setup:
msm_rpc_unregister_client(rtc_pdata->rpc_client);
kfree(rtc_pdata);
return rc;
}
