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 audio_release(struct inode *inode, struct file *file)
{
struct audio *audio = file->private_data;
mutex_lock(&audio->lock);
if (audio->enabled) {
audio->stopped = 1;
audio_disable(audio);
audio->running = 0;
audio->enabled = 0;
wake_up(&audio->wait);
}
msm_rpc_unregister_client(audio->client);
kfree(audio->data);
audio->data = NULL;
audio->opened = 0;
mutex_unlock(&audio->lock);
return 0;
}
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;
}
static void __devexit hs_rpc_deinit(void)
{
if (rpc_client)
msm_rpc_unregister_client(rpc_client);
}
/* 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;
}
void msm_lightsensor_cleanup(void)
{
if (light_client)
msm_rpc_unregister_client(light_client);
}
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;
}
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
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 __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;
}
void msm_fsusb_rpc_deinit(void)
{
msm_rpc_unregister_client(client);
}
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;
}
void msm_ear_cleanup(void)
{
if (ear_client)
msm_rpc_unregister_client(ear_client);
}
