← Back to branch summary

~phablet-team/ofono/ofono-bug-updates

« back to all changes in this revision

Viewing changes to drivers/rilmodem/call-settings.c

  • Committer: Denis Kenzior
  • Author(s): Lucas De Marchi
  • Date: 2011-03-18 23:31:14 UTC
  • Revision ID: git-v1:888e07863b24026413bac8f449de377c879e1044
message: add cancelled state

Based on patch from Yang Gu <gyagp0@gmail.com>

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/rilmodem/call-settings.c
1
 
/*
2
 
 *
3
 
 *  oFono - Open Source Telephony
4
 
 *
5
 
 *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
6
 
 *  Copyright (C) 2013 Jolla Ltd
7
 
 *  Copyright (C) 2013 Canonical Ltd
8
 
 *  Contact: Jussi Kangas <jussi.kangas@tieto.com>
9
 
 *
10
 
 *  This program is free software; you can redistribute it and/or modify
11
 
 *  it under the terms of the GNU General Public License version 2 as
12
 
 *  published by the Free Software Foundation.
13
 
 *
14
 
 *  This program is distributed in the hope that it will be useful,
15
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
 
 *  GNU General Public License for more details.
18
 
 *
19
 
 *  You should have received a copy of the GNU General Public License
20
 
 *  along with this program; if not, write to the Free Software
21
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
22
 
 *
23
 
 */
24
 
 
25
 
#ifdef HAVE_CONFIG_H
26
 
#include <config.h>
27
 
#endif
28
 
 
29
 
#define _GNU_SOURCE
30
 
#include <stdio.h>
31
 
#include <stdlib.h>
32
 
#include <string.h>
33
 
#include <errno.h>
34
 
 
35
 
#include <glib.h>
36
 
 
37
 
#include <ofono/log.h>
38
 
#include <ofono/modem.h>
39
 
#include <ofono/call-settings.h>
40
 
 
41
 
#include "gril.h"
42
 
#include "grilutil.h"
43
 
#include "grilrequest.h"
44
 
#include "grilreply.h"
45
 
 
46
 
#include "rilmodem.h"
47
 
#include "ril_constants.h"
48
 
#include "common.h"
49
 
 
50
 
struct settings_data {
51
 
        GRil *ril;
52
 
};
53
 
 
54
 
static void ril_set_cb(struct ril_msg *message, gpointer user_data)
55
 
{
56
 
        struct cb_data *cbd = user_data;
57
 
        struct ofono_call_settings *cs = cbd->user;
58
 
        struct settings_data *sd = ofono_call_settings_get_data(cs);
59
 
        ofono_call_settings_set_cb_t cb = cbd->cb;
60
 
 
61
 
        if (message->error == RIL_E_SUCCESS) {
62
 
                g_ril_print_response_no_args(sd->ril, message);
63
 
                CALLBACK_WITH_SUCCESS(cb, cbd->data);
64
 
        } else {
65
 
                CALLBACK_WITH_FAILURE(cb, cbd->data);
66
 
        }
67
 
}
68
 
 
69
 
static void ril_cw_set(struct ofono_call_settings *cs, int mode, int cls,
70
 
                        ofono_call_settings_set_cb_t cb, void *data)
71
 
{
72
 
        struct settings_data *sd = ofono_call_settings_get_data(cs);
73
 
        struct cb_data *cbd = cb_data_new(cb, data, cs);
74
 
        int ret;
75
 
        struct parcel rilp;
76
 
 
77
 
        g_ril_request_set_call_waiting(sd->ril, mode, cls, &rilp);
78
 
 
79
 
        ret = g_ril_send(sd->ril, RIL_REQUEST_SET_CALL_WAITING, &rilp,
80
 
                                ril_set_cb, cbd, g_free);
81
 
 
82
 
        /* In case of error free cbd and return the cb with failure */
83
 
        if (ret <= 0) {
84
 
                g_free(cbd);
85
 
                CALLBACK_WITH_FAILURE(cb, data);
86
 
        }
87
 
}
88
 
 
89
 
static void ril_cw_query_cb(struct ril_msg *message, gpointer user_data)
90
 
{
91
 
        struct cb_data *cbd = user_data;
92
 
        struct ofono_call_settings *cs = cbd->user;
93
 
        struct settings_data *sd = ofono_call_settings_get_data(cs);
94
 
        ofono_call_settings_status_cb_t cb = cbd->cb;
95
 
 
96
 
        if (message->error == RIL_E_SUCCESS) {
97
 
                int res;
98
 
 
99
 
                res = g_ril_reply_parse_query_call_waiting(sd->ril, message);
100
 
 
101
 
                CALLBACK_WITH_SUCCESS(cb, res, cbd->data);
102
 
        } else {
103
 
                CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
104
 
        }
105
 
}
106
 
 
107
 
static void ril_cw_query(struct ofono_call_settings *cs, int cls,
108
 
                                ofono_call_settings_status_cb_t cb, void *data)
109
 
{
110
 
        struct settings_data *sd = ofono_call_settings_get_data(cs);
111
 
        struct cb_data *cbd = cb_data_new(cb, data, cs);
112
 
        int ret;
113
 
        struct parcel rilp;
114
 
 
115
 
        g_ril_request_query_call_waiting(sd->ril, cls, &rilp);
116
 
 
117
 
        ret = g_ril_send(sd->ril, RIL_REQUEST_QUERY_CALL_WAITING, &rilp,
118
 
                                ril_cw_query_cb, cbd, g_free);
119
 
 
120
 
        /* In case of error free cbd and return the cb with failure */
121
 
        if (ret <= 0) {
122
 
                g_free(cbd);
123
 
                CALLBACK_WITH_FAILURE(cb, -1, data);
124
 
        }
125
 
}
126
 
 
127
 
static void ril_clip_query_cb(struct ril_msg *message, gpointer user_data)
128
 
{
129
 
        struct cb_data *cbd = user_data;
130
 
        struct ofono_call_settings *cs = cbd->user;
131
 
        struct settings_data *sd = ofono_call_settings_get_data(cs);
132
 
        ofono_call_settings_status_cb_t cb = cbd->cb;
133
 
 
134
 
        if (message->error == RIL_E_SUCCESS) {
135
 
                int res;
136
 
 
137
 
                res = g_ril_reply_parse_query_clip(sd->ril, message);
138
 
 
139
 
                CALLBACK_WITH_SUCCESS(cb, res, cbd->data);
140
 
        } else {
141
 
                CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
142
 
        }
143
 
}
144
 
 
145
 
static void ril_clip_query(struct ofono_call_settings *cs,
146
 
                        ofono_call_settings_status_cb_t cb, void *data)
147
 
{
148
 
        struct settings_data *sd = ofono_call_settings_get_data(cs);
149
 
        struct cb_data *cbd = cb_data_new(cb, data, cs);
150
 
        int ret;
151
 
 
152
 
        ret = g_ril_send(sd->ril, RIL_REQUEST_QUERY_CLIP, NULL,
153
 
                                ril_clip_query_cb, cbd, g_free);
154
 
 
155
 
        /* In case of error free cbd and return the cb with failure */
156
 
        if (ret <= 0) {
157
 
                g_free(cbd);
158
 
                CALLBACK_WITH_FAILURE(cb, -1, data);
159
 
        }
160
 
}
161
 
 
162
 
static void ril_clir_query_cb(struct ril_msg *message, gpointer user_data)
163
 
{
164
 
        struct cb_data *cbd = user_data;
165
 
        struct ofono_call_settings *cs = cbd->user;
166
 
        struct settings_data *sd = ofono_call_settings_get_data(cs);
167
 
        ofono_call_settings_clir_cb_t cb = cbd->cb;
168
 
        struct reply_clir *rclir;
169
 
 
170
 
        if (message->error != RIL_E_SUCCESS) {
171
 
                ofono_error("%s: Reply failure: %s", __func__,
172
 
                                ril_error_to_string(message->error));
173
 
                goto error;
174
 
        }
175
 
 
176
 
        rclir = g_ril_reply_parse_get_clir(sd->ril, message);
177
 
        if (rclir == NULL) {
178
 
                ofono_error("%s: parse error", __func__);
179
 
                goto error;
180
 
        }
181
 
 
182
 
        CALLBACK_WITH_SUCCESS(cb, rclir->status, rclir->provisioned, cbd->data);
183
 
 
184
 
        g_ril_reply_free_get_clir(rclir);
185
 
 
186
 
        return;
187
 
 
188
 
error:
189
 
        CALLBACK_WITH_FAILURE(cb, -1, -1, cbd->data);
190
 
}
191
 
 
192
 
static void ril_clir_query(struct ofono_call_settings *cs,
193
 
                        ofono_call_settings_clir_cb_t cb, void *data)
194
 
{
195
 
        struct settings_data *sd = ofono_call_settings_get_data(cs);
196
 
        struct cb_data *cbd = cb_data_new(cb, data, cs);
197
 
        int ret;
198
 
 
199
 
        ret = g_ril_send(sd->ril, RIL_REQUEST_GET_CLIR, NULL,
200
 
                                ril_clir_query_cb, cbd, g_free);
201
 
 
202
 
        if (ret <= 0) {
203
 
                g_free(cbd);
204
 
                CALLBACK_WITH_FAILURE(cb, -1, -1, data);
205
 
        }
206
 
}
207
 
 
208
 
 
209
 
static void ril_clir_set(struct ofono_call_settings *cs, int mode,
210
 
                        ofono_call_settings_set_cb_t cb, void *data)
211
 
{
212
 
        struct settings_data *sd = ofono_call_settings_get_data(cs);
213
 
        struct cb_data *cbd = cb_data_new(cb, data, cs);
214
 
        struct parcel rilp;
215
 
        int ret;
216
 
 
217
 
        g_ril_request_set_clir(sd->ril, mode, &rilp);
218
 
 
219
 
        ret = g_ril_send(sd->ril, RIL_REQUEST_SET_CLIR, &rilp,
220
 
                                ril_set_cb, cbd, g_free);
221
 
 
222
 
        if (ret <= 0) {
223
 
                g_free(cbd);
224
 
                CALLBACK_WITH_FAILURE(cb, data);
225
 
        }
226
 
}
227
 
 
228
 
static gboolean ril_delayed_register(gpointer user_data)
229
 
{
230
 
        struct ofono_call_settings *cs = user_data;
231
 
 
232
 
        ofono_call_settings_register(cs);
233
 
 
234
 
        return FALSE;
235
 
}
236
 
 
237
 
static int ril_call_settings_probe(struct ofono_call_settings *cs,
238
 
                                        unsigned int vendor, void *user)
239
 
{
240
 
        GRil *ril = user;
241
 
        struct settings_data *sd = g_new0(struct settings_data, 1);
242
 
 
243
 
        sd->ril = g_ril_clone(ril);
244
 
 
245
 
        ofono_call_settings_set_data(cs, sd);
246
 
 
247
 
        g_idle_add(ril_delayed_register, cs);
248
 
 
249
 
        return 0;
250
 
}
251
 
 
252
 
static void ril_call_settings_remove(struct ofono_call_settings *cs)
253
 
{
254
 
        struct settings_data *sd = ofono_call_settings_get_data(cs);
255
 
        ofono_call_settings_set_data(cs, NULL);
256
 
 
257
 
        g_ril_unref(sd->ril);
258
 
        g_free(sd);
259
 
}
260
 
 
261
 
static struct ofono_call_settings_driver driver = {
262
 
        .name                   = RILMODEM,
263
 
        .probe                  = ril_call_settings_probe,
264
 
        .remove                 = ril_call_settings_remove,
265
 
        .clip_query             = ril_clip_query,
266
 
        .cw_query               = ril_cw_query,
267
 
        .cw_set                 = ril_cw_set,
268
 
        .clir_query             = ril_clir_query,
269
 
        .clir_set               = ril_clir_set
270
 
 
271
 
        /*
272
 
         * Not supported in RIL API
273
 
         * .colp_query          = ril_colp_query,
274
 
         * .colr_query          = ril_colr_query
275
 
         */
276
 
};
277
 
 
278
 
void ril_call_settings_init(void)
279
 
{
280
 
        ofono_call_settings_driver_register(&driver);
281
 
}
282
 
 
283
 
void ril_call_settings_exit(void)
284
 
{
285
 
        ofono_call_settings_driver_unregister(&driver);
286
 
}