diff --git a/drivers/Makefile.am b/drivers/Makefile.am index 1e7db353..87a26644 100644 --- a/drivers/Makefile.am +++ b/drivers/Makefile.am @@ -15,7 +15,12 @@ builtin_sources += atmodem/atmodem.c atmodem/at.h \ if COND_ISI builtin_modules += isimodem builtin_sources += isimodem/isimodem.c isimodem/isi.h isimodem/isiphonebook.c \ - isimodem/isidevinfo.c + isimodem/isidevinfo.c isimodem/isinetwork.c \ + isimodem/isivoicecall.c isimodem/isisms.c \ + isimodem/isisim.c isimodem/isissn.c \ + isimodem/isiussd.c isimodem/isicall-forwarding.c \ + isimodem/isicall-settings.c isimodem/isicall-barring.c \ + isimodem/isicall-meter.c endif noinst_LTLIBRARIES = libbuiltin.la diff --git a/drivers/isimodem/isi.h b/drivers/isimodem/isi.h index 134359e0..89ed5346 100644 --- a/drivers/isimodem/isi.h +++ b/drivers/isimodem/isi.h @@ -38,6 +38,11 @@ struct isi_cb_data { void *user; }; +struct isi_version { + unsigned short major; + unsigned short minor; +}; + static inline struct isi_cb_data *isi_cb_data_new(struct ofono_modem *modem, void *cb, void *data) { @@ -70,3 +75,33 @@ extern void isi_phonebook_exit(); extern void isi_devinfo_init(); extern void isi_devinfo_exit(); + +extern void isi_netreg_init(); +extern void isi_netreg_exit(); + +extern void isi_voicecall_init(); +extern void isi_voicecall_exit(); + +extern void isi_sms_init(); +extern void isi_sms_exit(); + +extern void isi_sim_init(); +extern void isi_sim_exit(); + +extern void isi_ussd_init(); +extern void isi_ussd_exit(); + +extern void isi_ssn_init(); +extern void isi_ssn_exit(); + +extern void isi_call_forwarding_init(); +extern void isi_call_forwarding_exit(); + +extern void isi_call_settings_init(); +extern void isi_call_settings_exit(); + +extern void isi_call_barring_init(); +extern void isi_call_barring_exit(); + +extern void isi_call_meter_init(); +extern void isi_call_meter_exit(); diff --git a/drivers/isimodem/isicall-barring.c b/drivers/isimodem/isicall-barring.c new file mode 100644 index 00000000..e7102be7 --- /dev/null +++ b/drivers/isimodem/isicall-barring.c @@ -0,0 +1,124 @@ +/* + * This file is part of oFono - Open Source Telephony + * + * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). + * + * Contact: Aki Niemi + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#define _GNU_SOURCE +#include +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include + +#include "isi.h" + +#define PN_SS 0x06 + +struct call_barring_data { + GIsiClient *client; + struct isi_version version; +}; + +static void isi_set(struct ofono_call_barring *barr, const char *lock, + int enable, const char *passwd, int cls, + ofono_call_barring_set_cb_t cb, void *data) +{ +} + +static void isi_query(struct ofono_call_barring *barr, const char *lock, int cls, + ofono_call_barring_query_cb_t cb, void *data) +{ +} + +static void isi_set_passwd(struct ofono_call_barring *barr, const char *lock, + const char *old_passwd, const char *new_passwd, + ofono_call_barring_set_cb_t cb, void *data) +{ +} + +static gboolean isi_call_barring_register(gpointer user) +{ + struct ofono_call_barring *barr = user; + + ofono_call_barring_register(barr); + + return FALSE; +} + +static int isi_call_barring_probe(struct ofono_call_barring *barr) +{ + GIsiModem *idx = ofono_call_barring_get_data(barr); + struct call_barring_data *data = g_try_new0(struct call_barring_data, 1); + + if (!data) + return -ENOMEM; + + data->client = g_isi_client_create(idx, PN_SS); + if (!data->client) + return -ENOMEM; + + ofono_call_barring_set_data(barr, data); + + return 0; +} + +static int isi_call_barring_remove(struct ofono_call_barring *barr) +{ + struct call_barring_data *data = ofono_call_barring_get_data(barr); + + if (data) { + g_isi_client_destroy(data->client); + g_free(data); + } + + return 0; +} + +static struct ofono_call_barring_driver driver = { + .name = "isi", + .probe = isi_call_barring_probe, + .remove = isi_call_barring_remove, + .set = isi_set, + .query = isi_query, + .set_passwd = isi_set_passwd +}; + +void isi_call_barring_init() +{ + ofono_call_barring_driver_register(&driver); +} + +void isi_call_barring_exit() +{ + ofono_call_barring_driver_unregister(&driver); +} diff --git a/drivers/isimodem/isicall-forwarding.c b/drivers/isimodem/isicall-forwarding.c new file mode 100644 index 00000000..056ebd62 --- /dev/null +++ b/drivers/isimodem/isicall-forwarding.c @@ -0,0 +1,140 @@ +/* + * This file is part of oFono - Open Source Telephony + * + * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). + * + * Contact: Aki Niemi + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#define _GNU_SOURCE +#include +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include + +#include "isi.h" + +#define PN_SS 0x06 + +struct call_forwarding_data { + GIsiClient *client; + struct isi_version version; +}; + +static void isi_activation(struct ofono_call_forwarding *cf, + int type, int cls, + ofono_call_forwarding_set_cb_t cb, void *data) +{ +} + +static void isi_registration(struct ofono_call_forwarding *cf, + int type, int cls, + const struct ofono_phone_number *number, + int time, + ofono_call_forwarding_set_cb_t cb, void *data) +{ +} + +static void isi_deactivation(struct ofono_call_forwarding *cf, + int type, int cls, + ofono_call_forwarding_set_cb_t cb, void *data) +{ +} + +static void isi_erasure(struct ofono_call_forwarding *cf, int type, int cls, + ofono_call_forwarding_set_cb_t cb, void *data) +{ +} + +static void isi_query(struct ofono_call_forwarding *cf, int type, int cls, + ofono_call_forwarding_query_cb_t cb, + void *data) +{ +} + +static gboolean isi_call_forwarding_register(gpointer user) +{ + struct ofono_call_forwarding *cf = user; + + ofono_call_forwarding_register(cf); + + return FALSE; +} + +static int isi_call_forwarding_probe(struct ofono_call_forwarding *cf) +{ + GIsiModem *idx = ofono_call_forwarding_get_data(cf); + struct call_forwarding_data *data = g_try_new0(struct call_forwarding_data, 1); + + if (!data) + return -ENOMEM; + + data->client = g_isi_client_create(idx, PN_SS); + if (!data->client) + return -ENOMEM; + + ofono_call_forwarding_set_data(cf, data); + + return 0; +} + +static int isi_call_forwarding_remove(struct ofono_call_forwarding *cf) +{ + struct call_forwarding_data *data = ofono_call_forwarding_get_data(cf); + + if (data) { + g_isi_client_destroy(data->client); + g_free(data); + } + + return 0; +} + +static struct ofono_call_forwarding_driver driver = { + .name = "isi", + .probe = isi_call_forwarding_probe, + .remove = isi_call_forwarding_remove, + .activation = isi_activation, + .registration = isi_registration, + .deactivation = isi_deactivation, + .erasure = isi_erasure, + .query = isi_query +}; + +void isi_call_forwarding_init() +{ + ofono_call_forwarding_driver_register(&driver); +} + +void isi_call_forwarding_exit() +{ + ofono_call_forwarding_driver_unregister(&driver); +} diff --git a/drivers/isimodem/isicall-meter.c b/drivers/isimodem/isicall-meter.c new file mode 100644 index 00000000..5736ec24 --- /dev/null +++ b/drivers/isimodem/isicall-meter.c @@ -0,0 +1,150 @@ +/* + * This file is part of oFono - Open Source Telephony + * + * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). + * + * Contact: Aki Niemi + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#define _GNU_SOURCE +#include +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include + +#include "isi.h" + +#define PN_SS 0x06 + +struct call_meter_data { + GIsiClient *client; + struct isi_version version; +}; + +static void isi_call_meter_query(struct ofono_call_meter *cm, + ofono_call_meter_query_cb_t cb, + void *data) +{ +} + +static void isi_acm_query(struct ofono_call_meter *cm, + ofono_call_meter_query_cb_t cb, + void *data) +{ +} + +static void isi_acm_reset(struct ofono_call_meter *cm, const char *sim_pin2, + ofono_call_meter_set_cb_t cb, void *data) +{ +} + +static void isi_acm_max_query(struct ofono_call_meter *cm, + ofono_call_meter_query_cb_t cb, void *data) +{ +} + +static void isi_acm_max_set(struct ofono_call_meter *cm, int new_value, + const char *sim_pin2, + ofono_call_meter_set_cb_t cb, void *data) +{ +} + +static void isi_puct_query(struct ofono_call_meter *cm, + ofono_call_meter_puct_query_cb_t cb, void *data) +{ +} + +static void isi_puct_set(struct ofono_call_meter *cm, const char *currency, + double ppu, const char *sim_pin2, + ofono_call_meter_set_cb_t cb, void *data) +{ +} + +static gboolean isi_call_meter_register(gpointer user) +{ + struct ofono_call_meter *cm = user; + + ofono_call_meter_register(cm); + + return FALSE; +} + +static int isi_call_meter_probe(struct ofono_call_meter *cm) +{ + GIsiModem *idx = ofono_call_meter_get_data(cm); + struct call_meter_data *data = g_try_new0(struct call_meter_data, 1); + + if (!data) + return -ENOMEM; + + data->client = g_isi_client_create(idx, PN_SS); + if (!data->client) + return -ENOMEM; + + ofono_call_meter_set_data(cm, data); + + return 0; +} + +static int isi_call_meter_remove(struct ofono_call_meter *cm) +{ + struct call_meter_data *data = ofono_call_meter_get_data(cm); + + if (data) { + g_isi_client_destroy(data->client); + g_free(data); + } + + return 0; +} + +static struct ofono_call_meter_driver driver = { + .name = "isi", + .probe = isi_call_meter_probe, + .remove = isi_call_meter_remove, + .call_meter_query = isi_call_meter_query, + .acm_query = isi_acm_query, + .acm_reset = isi_acm_reset, + .acm_max_query = isi_acm_max_query, + .acm_max_set = isi_acm_max_set, + .puct_query = isi_puct_query, + .puct_set = isi_puct_set +}; + +void isi_call_meter_init() +{ + ofono_call_meter_driver_register(&driver); +} + +void isi_call_meter_exit() +{ + ofono_call_meter_driver_unregister(&driver); +} diff --git a/drivers/isimodem/isicall-settings.c b/drivers/isimodem/isicall-settings.c new file mode 100644 index 00000000..b5df8132 --- /dev/null +++ b/drivers/isimodem/isicall-settings.c @@ -0,0 +1,146 @@ +/* + * This file is part of oFono - Open Source Telephony + * + * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). + * + * Contact: Aki Niemi + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#define _GNU_SOURCE +#include +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include + +#include "isi.h" + +#define PN_SS 0x06 + +struct call_settings_data { + GIsiClient *client; + struct isi_version version; +}; + +static void isi_clip_query(struct ofono_call_settings *cs, + ofono_call_settings_status_cb_t cb, void *data) +{ +} + +static void isi_colp_query(struct ofono_call_settings *cs, + ofono_call_settings_status_cb_t cb, void *data) +{ +} + +static void isi_clir_query(struct ofono_call_settings *cs, + ofono_call_settings_clir_cb_t cb, void *data) +{ +} + +static void isi_colr_query(struct ofono_call_settings *cs, + ofono_call_settings_status_cb_t cb, void *data) +{ +} + +static void isi_clir_set(struct ofono_call_settings *cs, int mode, + ofono_call_settings_set_cb_t cb, void *data) +{ +} + +static void isi_cw_query(struct ofono_call_settings *cs, int cls, + ofono_call_settings_status_cb_t cb, void *data) +{ +} + +static void isi_cw_set(struct ofono_call_settings *cs, int mode, int cls, + ofono_call_settings_set_cb_t cb, void *data) +{ +} + +static gboolean isi_call_settings_register(gpointer user) +{ + struct ofono_call_settings *cs = user; + + ofono_call_settings_register(cs); + + return FALSE; +} + +static int isi_call_settings_probe(struct ofono_call_settings *cs) +{ + GIsiModem *idx = ofono_call_settings_get_data(cs); + struct call_settings_data *data = g_try_new0(struct call_settings_data, 1); + + if (!data) + return -ENOMEM; + + data->client = g_isi_client_create(idx, PN_SS); + if (!data->client) + return -ENOMEM; + + ofono_call_settings_set_data(cs, data); + + return 0; +} + +static int isi_call_settings_remove(struct ofono_call_settings *cs) +{ + struct call_settings_data *data = ofono_call_settings_get_data(cs); + + if (data) { + g_isi_client_destroy(data->client); + g_free(data); + } + + return 0; +} + +static struct ofono_call_settings_driver driver = { + .name = "isi", + .probe = isi_call_settings_probe, + .remove = isi_call_settings_remove, + .clip_query = isi_clip_query, + .colp_query = isi_colp_query, + .clir_query = isi_clir_query, + .colr_query = isi_colr_query, + .clir_set = isi_clir_set, + .cw_query = isi_cw_query, + .cw_set = isi_cw_set +}; + +void isi_call_settings_init() +{ + ofono_call_settings_driver_register(&driver); +} + +void isi_call_settings_exit() +{ + ofono_call_settings_driver_unregister(&driver); +} diff --git a/drivers/isimodem/isimodem.c b/drivers/isimodem/isimodem.c index c5dce397..4a01dd3c 100644 --- a/drivers/isimodem/isimodem.c +++ b/drivers/isimodem/isimodem.c @@ -38,6 +38,16 @@ #include #include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include "isi.h" @@ -140,6 +150,16 @@ static int isi_modem_populate(struct ofono_modem *modem) ofono_devinfo_create(isi->modem, "isi", isi->idx); ofono_phonebook_create(isi->modem, "isi", isi->idx); + ofono_netreg_create(isi->modem, "isi", isi->idx); + ofono_voicecall_create(isi->modem, "isi", isi->idx); + ofono_sms_create(isi->modem, "isi", isi->idx); + ofono_sim_create(isi->modem, "isi", isi->idx); + ofono_ssn_create(isi->modem, "isi", isi->idx); + ofono_ussd_create(isi->modem, "isi", isi->idx); + ofono_call_forwarding_create(isi->modem, "isi", isi->idx); + ofono_call_settings_create(isi->modem, "isi", isi->idx); + ofono_call_barring_create(isi->modem, "isi", isi->idx); + ofono_call_meter_create(isi->modem, "isi", isi->idx); return 0; } @@ -159,6 +179,16 @@ static int isimodem_init(void) isi_devinfo_init(); isi_phonebook_init(); + isi_netreg_init(); + isi_voicecall_init(); + isi_sms_init(); + isi_sim_init(); + isi_ssn_init(); + isi_ussd_init(); + isi_call_forwarding_init(); + isi_call_settings_init(); + isi_call_barring_init(); + isi_call_meter_init(); ofono_modem_driver_register(&driver); @@ -188,6 +218,16 @@ static void isimodem_exit(void) isi_devinfo_exit(); isi_phonebook_exit(); + isi_netreg_exit(); + isi_voicecall_exit(); + isi_sms_exit(); + isi_sim_exit(); + isi_ssn_exit(); + isi_ussd_exit(); + isi_call_forwarding_exit(); + isi_call_settings_exit(); + isi_call_barring_exit(); + isi_call_meter_exit(); } OFONO_PLUGIN_DEFINE(isimodem, "PhoNet / ISI modem driver", VERSION, diff --git a/drivers/isimodem/isinetwork.c b/drivers/isimodem/isinetwork.c new file mode 100644 index 00000000..e2a65940 --- /dev/null +++ b/drivers/isimodem/isinetwork.c @@ -0,0 +1,237 @@ +/* + * This file is part of oFono - Open Source Telephony + * + * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). + * + * Contact: Aki Niemi + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#define _GNU_SOURCE +#include +#include +#include +#include +#include + +#include + +#include +#include + +#include +#include +#include +#include + +#include "isi.h" + +#define PN_NETWORK 0x0A +#define NETWORK_TIMEOUT 5 +#define NETWORK_SCAN_TIMEOUT 60 + +/* Used with COMMON_MESSAGE */ +enum sub_message_id { + COMM_ISI_VERSION_GET_REQ = 0x12, + COMM_ISI_VERSION_GET_RESP = 0x13, + COMM_ISA_ENTITY_NOT_REACHABLE_RESP = 0x14 +}; + +enum message_id { + NET_SET_REQ = 0x07, + NET_SET_RESP = 0x08, + NET_SET_CANCEL_REQ = 0x09, + NET_SET_CANCEL_RESP = 0x0A, + NET_RSSI_GET_REQ = 0x0B, + NET_RSSI_GET_RESP = 0x0C, + NET_RSSI_IND = 0x1E, + NET_NITZ_NAME_IND = 0x43, + NET_REG_STATUS_GET_REQ = 0xE0, + NET_REG_STATUS_GET_RESP = 0xE1, + NET_REG_STATUS_IND = 0xE2, + NET_AVAILABLE_GET_REQ = 0xE3, + NET_AVAILABLE_GET_RESP = 0xE4, + NET_OPER_NAME_GET_REQ = 0xE5, + NET_OPER_NAME_GET_RESP = 0xE6, + COMMON_MESSAGE = 0xF0 +}; + +enum sub_block_id { + NET_REG_INFO_COMMON = 0x00, + NET_RSSI_CURRENT = 0x04, + NET_GSM_REG_INFO = 0x09, + NET_GSM_BAND_INFO = 0x11 +}; + +enum reg_status { + NET_REG_STATUS_HOME = 0x00, + NET_REG_STATUS_ROAM = 0x01, + NET_REG_STATUS_NOSERV = 0x03, + NET_REG_STATUS_NOSERV_SEARCHING = 0x04, + NET_REG_STATUS_NOSERV_NOTSEARCHING = 0x05, + NET_REG_STATUS_NOSERV_NOSIM = 0x06, + NET_REG_STATUS_POWER_OFF = 0x08, + NET_REG_STATUS_NSPS = 0x09, + NET_REG_STATUS_NSPS_NO_COVERAGE = 0x0A, + NET_REG_STATUS_NOSERV_SIM_REJECTED_BY_NW = 0x0B +}; + +enum cs_type { + NET_CS_GSM = 0x00 +}; + +enum measurement_type { + NET_CURRENT_CELL_RSSI = 0x02 +}; + +enum search_mode { + NET_MANUAL_SEARCH = 0x00 +}; + +enum band_info { + NET_GSM_BAND_ALL_SUPPORTED_BANDS = 0x03 +}; + +enum select_mode { + NET_SELECT_MODE_UNKNOWN = 0x00, + NET_SELECT_MODE_MANUAL = 0x01, + NET_SELECT_MODE_AUTOMATIC = 0x02 +}; + +enum return_code { + NET_CAUSE_OK = 0x00, + NET_CAUSE_COMMUNICATION_ERROR = 0x01, + NET_CAUSE_NET_NOT_FOUND = 0x05, + NET_CAUSE_NO_SELECTED_NETWORK = 0x11 +}; + +struct netreg_data { + GIsiClient *client; + struct isi_version version; +}; + +static void isi_registration_status(struct ofono_netreg *netreg, + ofono_netreg_status_cb_t cb, + void *data) +{ +} + +static void isi_current_operator(struct ofono_netreg *netreg, + ofono_netreg_operator_cb_t cb, + void *data) +{ +} + +static void isi_list_operators(struct ofono_netreg *netreg, + ofono_netreg_operator_list_cb_t cb, + void *data) +{ +} + +static void isi_register_auto(struct ofono_netreg *netreg, + ofono_netreg_register_cb_t cb, + void *data) +{ +} + +static void isi_register_manual(struct ofono_netreg *netreg, + const struct ofono_network_operator *oper, + ofono_netreg_register_cb_t cb, void *data) +{ +} + +static void isi_deregister(struct ofono_netreg *netreg, + ofono_netreg_register_cb_t cb, + void *data) +{ +} + +static void isi_strength(struct ofono_netreg *netreg, + ofono_netreg_strength_cb_t cb, + void *data) +{ +} + +static gboolean isi_netreg_register(gpointer user) +{ + struct ofono_netreg *net = user; + struct netreg_data *data = ofono_netreg_get_data(net); + + ofono_netreg_register(net); + + return FALSE; +} + +static int isi_netreg_probe(struct ofono_netreg *netreg) +{ + GIsiModem *idx = ofono_netreg_get_data(netreg); + struct netreg_data *user = g_try_new0(struct netreg_data, 1); + + if (!user) + return -ENOMEM; + + user->client = g_isi_client_create(idx, PN_NETWORK); + if (!user->client) { + g_free(user); + return -ENOMEM; + } + + ofono_netreg_set_data(netreg, user); + + g_idle_add(isi_netreg_register, netreg); + + return 0; +} + +static int isi_netreg_remove(struct ofono_netreg *net) +{ + struct netreg_data *data = ofono_netreg_get_data(net); + + if (data && data->client) { + g_isi_client_destroy(data->client); + g_free(data); + } + + return 0; +} + +static struct ofono_netreg_driver driver = { + .name = "isi", + .probe = isi_netreg_probe, + .remove = isi_netreg_remove, + .registration_status = isi_registration_status, + .current_operator = isi_current_operator, + .list_operators = isi_list_operators, + .register_auto = isi_register_auto, + .register_manual = isi_register_manual, + .deregister = isi_deregister, + .strength = isi_strength, +}; + +void isi_netreg_init() +{ + ofono_netreg_driver_register(&driver); +} + +void isi_netreg_exit() +{ + ofono_netreg_driver_unregister(&driver); +} diff --git a/drivers/isimodem/isisim.c b/drivers/isimodem/isisim.c new file mode 100644 index 00000000..b50083da --- /dev/null +++ b/drivers/isimodem/isisim.c @@ -0,0 +1,160 @@ +/* + * This file is part of oFono - Open Source Telephony + * + * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). + * + * Contact: Aki Niemi + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#define _GNU_SOURCE +#include +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include + +#include "isi.h" + +#define PN_SIM 0x09 + +struct sim_data { + GIsiClient *client; + struct isi_version version; +}; + +static void isi_read_file_info(struct ofono_sim *sim, int fileid, + ofono_sim_file_info_cb_t cb, void *data) +{ +} + +static void isi_read_file_transparent(struct ofono_sim *sim, int fileid, + int start, int length, + ofono_sim_read_cb_t cb, void *data) +{ +} + +static void isi_read_file_linear(struct ofono_sim *sim, int fileid, + int record, int length, + ofono_sim_read_cb_t cb, void *data) +{ +} + +static void isi_read_file_cyclic(struct ofono_sim *sim, int fileid, + int record, int length, + ofono_sim_read_cb_t cb, void *data) +{ +} + +static void isi_write_file_transparent(struct ofono_sim *sim, int fileid, + int start, int length, + const unsigned char *value, + ofono_sim_write_cb_t cb, void *data) +{ +} + +static void isi_write_file_linear(struct ofono_sim *sim, int fileid, + int record, int length, + const unsigned char *value, + ofono_sim_write_cb_t cb, void *data) +{ +} + +static void isi_write_file_cyclic(struct ofono_sim *sim, int fileid, + int length, const unsigned char *value, + ofono_sim_write_cb_t cb, void *data) +{ +} + +static void isi_read_imsi(struct ofono_sim *sim, + ofono_sim_imsi_cb_t cb, void *data) +{ +} + +static gboolean isi_sim_register(gpointer user) +{ + struct ofono_sim *sim = user; + + ofono_sim_register(sim); + + return FALSE; +} + +static int isi_sim_probe(struct ofono_sim *sim) +{ + GIsiModem *idx = ofono_sim_get_data(sim); + struct sim_data *data = g_try_new0(struct sim_data, 1); + + if (!data) + return -ENOMEM; + + data->client = g_isi_client_create(idx, PN_SIM); + if (!data->client) + return -ENOMEM; + + ofono_sim_set_data(sim, data); + + return 0; +} + +static int isi_sim_remove(struct ofono_sim *sim) +{ + struct sim_data *data = ofono_sim_get_data(sim); + + if (data) { + g_isi_client_destroy(data->client); + g_free(data); + } + + return 0; +} + +static struct ofono_sim_driver driver = { + .name = "isi", + .probe = isi_sim_probe, + .remove = isi_sim_remove, + .read_file_info = isi_read_file_info, + .read_file_transparent = isi_read_file_transparent, + .read_file_linear = isi_read_file_linear, + .read_file_cyclic = isi_read_file_cyclic, + .write_file_transparent = isi_write_file_transparent, + .write_file_linear = isi_write_file_linear, + .write_file_cyclic = isi_write_file_cyclic, + .read_imsi = isi_read_imsi +}; + +void isi_sim_init() +{ + ofono_sim_driver_register(&driver); +} + +void isi_sim_exit() +{ + ofono_sim_driver_unregister(&driver); +} diff --git a/drivers/isimodem/isisms.c b/drivers/isimodem/isisms.c new file mode 100644 index 00000000..5f188566 --- /dev/null +++ b/drivers/isimodem/isisms.c @@ -0,0 +1,124 @@ +/* + * This file is part of oFono - Open Source Telephony + * + * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). + * + * Contact: Aki Niemi + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#define _GNU_SOURCE +#include +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include + +#include "isi.h" + +#define PN_SMS 0x02 + +struct sms_data { + GIsiClient *client; + struct isi_version version; +}; + +static void isi_sca_query(struct ofono_sms *sms, ofono_sms_sca_query_cb_t cb, + void *data) +{ +} + +static void isi_sca_set(struct ofono_sms *sms, + const struct ofono_phone_number *sca, + ofono_sms_sca_set_cb_t cb, void *data) +{ +} + +static void isi_submit(struct ofono_sms *sms, unsigned char *pdu, + int pdu_len, int tpdu_len, int mms, + ofono_sms_submit_cb_t cb, void *data) +{ +} + +static gboolean isi_sms_register(gpointer user) +{ + struct ofono_sms *sms = user; + + ofono_sms_register(sms); + + return FALSE; +} + +static int isi_sms_probe(struct ofono_sms *sms) +{ + GIsiModem *idx = ofono_sms_get_data(sms); + struct sms_data *data = g_try_new0(struct sms_data, 1); + + if (!data) + return -ENOMEM; + + data->client = g_isi_client_create(idx, PN_SMS); + if (!data->client) + return -ENOMEM; + + ofono_sms_set_data(sms, data); + + return 0; +} + +static int isi_sms_remove(struct ofono_sms *sms) +{ + struct sms_data *data = ofono_sms_get_data(sms); + + if (data) { + g_isi_client_destroy(data->client); + g_free(data); + } + + return 0; +} + +static struct ofono_sms_driver driver = { + .name = "isi", + .probe = isi_sms_probe, + .remove = isi_sms_remove, + .sca_query = isi_sca_query, + .sca_set = isi_sca_set, + .submit = isi_submit +}; + +void isi_sms_init() +{ + ofono_sms_driver_register(&driver); +} + +void isi_sms_exit() +{ + ofono_sms_driver_unregister(&driver); +} diff --git a/drivers/isimodem/isissn.c b/drivers/isimodem/isissn.c new file mode 100644 index 00000000..bd9a4ff8 --- /dev/null +++ b/drivers/isimodem/isissn.c @@ -0,0 +1,104 @@ +/* + * This file is part of oFono - Open Source Telephony + * + * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). + * + * Contact: Aki Niemi + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#define _GNU_SOURCE +#include +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include + +#include "isi.h" + +#define PN_SS 0x06 + +struct ssn_data { + GIsiClient *client; + struct isi_version version; +}; + +static gboolean isi_ssn_register(gpointer user) +{ + struct ofono_ssn *ssn = user; + + ofono_ssn_register(ssn); + + return FALSE; +} + +static int isi_ssn_probe(struct ofono_ssn *ssn) +{ + GIsiModem *idx = ofono_ssn_get_data(ssn); + struct ssn_data *data = g_try_new0(struct ssn_data, 1); + + if (!data) + return -ENOMEM; + + data->client = g_isi_client_create(idx, PN_SS); + if (!data->client) + return -ENOMEM; + + ofono_ssn_set_data(ssn, data); + + return 0; +} + +static int isi_ssn_remove(struct ofono_ssn *ssn) +{ + struct ssn_data *data = ofono_ssn_get_data(ssn); + + if (data) { + g_isi_client_destroy(data->client); + g_free(data); + } + + return 0; +} + +static struct ofono_ssn_driver driver = { + .name = "isi", + .probe = isi_ssn_probe, + .remove = isi_ssn_remove +}; + +void isi_ssn_init() +{ + ofono_ssn_driver_register(&driver); +} + +void isi_ssn_exit() +{ + ofono_ssn_driver_unregister(&driver); +} diff --git a/drivers/isimodem/isiussd.c b/drivers/isimodem/isiussd.c new file mode 100644 index 00000000..2c7bf30d --- /dev/null +++ b/drivers/isimodem/isiussd.c @@ -0,0 +1,116 @@ +/* + * This file is part of oFono - Open Source Telephony + * + * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). + * + * Contact: Aki Niemi + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#define _GNU_SOURCE +#include +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include + +#include "isi.h" + +#define PN_SS 0x06 + +struct ussd_data { + GIsiClient *client; + struct isi_version version; +}; + +static void isi_request(struct ofono_ussd *ussd, const char *str, + ofono_ussd_cb_t cb, void *data) +{ +} + +static void isi_cancel(struct ofono_ussd *ussd, + ofono_ussd_cb_t cb, void *data) +{ +} + +static gboolean isi_ussd_register(gpointer user) +{ + struct ofono_ussd *ussd = user; + + ofono_ussd_register(ussd); + + return FALSE; +} + +static int isi_ussd_probe(struct ofono_ussd *ussd) +{ + GIsiModem *idx = ofono_ussd_get_data(ussd); + struct ussd_data *data = g_try_new0(struct ussd_data, 1); + + if (!data) + return -ENOMEM; + + data->client = g_isi_client_create(idx, PN_SS); + if (!data->client) + return -ENOMEM; + + ofono_ussd_set_data(ussd, data); + + return 0; +} + +static int isi_ussd_remove(struct ofono_ussd *ussd) +{ + struct ussd_data *data = ofono_ussd_get_data(ussd); + + if (data) { + g_isi_client_destroy(data->client); + g_free(data); + } + + return 0; +} + +static struct ofono_ussd_driver driver = { + .name = "isi", + .probe = isi_ussd_probe, + .remove = isi_ussd_remove, + .request = isi_request, + .cancel = isi_cancel +}; + +void isi_ussd_init() +{ + ofono_ussd_driver_register(&driver); +} + +void isi_ussd_exit() +{ + ofono_ussd_driver_unregister(&driver); +} diff --git a/drivers/isimodem/isivoicecall.c b/drivers/isimodem/isivoicecall.c new file mode 100644 index 00000000..1e01a0ea --- /dev/null +++ b/drivers/isimodem/isivoicecall.c @@ -0,0 +1,198 @@ +/* + * This file is part of oFono - Open Source Telephony + * + * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). + * + * Contact: Aki Niemi + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA + * 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + +#define _GNU_SOURCE +#include +#include +#include +#include + +#include + +#include +#include + +#include +#include +#include +#include + +#include "isi.h" + +#define PN_CALL 0x01 + +struct voicecall_data { + GIsiClient *client; + struct isi_version version; +}; + +static void isi_dial(struct ofono_voicecall *vc, + const struct ofono_phone_number *number, + enum ofono_clir_option clir, enum ofono_cug_option cug, + ofono_voicecall_cb_t cb, void *data) +{ +} + +static void isi_answer(struct ofono_voicecall *vc, + ofono_voicecall_cb_t cb, void *data) +{ +} + +static void isi_hangup(struct ofono_voicecall *vc, + ofono_voicecall_cb_t cb, void *data) +{ +} + +static void isi_list_calls(struct ofono_voicecall *vc, + ofono_call_list_cb_t cb, void *data) +{ +} + +static void isi_hold_all_active(struct ofono_voicecall *vc, + ofono_voicecall_cb_t cb, void *data) +{ +} + +static void isi_release_all_held(struct ofono_voicecall *vc, + ofono_voicecall_cb_t cb, void *data) +{ +} + +static void isi_set_udub(struct ofono_voicecall *vc, + ofono_voicecall_cb_t cb, void *data) +{ +} + +static void isi_release_all_active(struct ofono_voicecall *vc, + ofono_voicecall_cb_t cb, void *data) +{ +} + +static void isi_release_specific(struct ofono_voicecall *vc, int id, + ofono_voicecall_cb_t cb, void *data) +{ +} + +static void isi_private_chat(struct ofono_voicecall *vc, int id, + ofono_voicecall_cb_t cb, void *data) +{ +} + +static void isi_create_multiparty(struct ofono_voicecall *vc, + ofono_voicecall_cb_t cb, void *data) +{ +} + +static void isi_transfer(struct ofono_voicecall *vc, + ofono_voicecall_cb_t cb, void *data) +{ +} + +static void isi_deflect(struct ofono_voicecall *vc, + const struct ofono_phone_number *ph, + ofono_voicecall_cb_t cb, void *data) +{ +} + +static void isi_swap_without_accept(struct ofono_voicecall *vc, + ofono_voicecall_cb_t cb, void *data) +{ +} + +static void isi_send_tones(struct ofono_voicecall *vc, const char *tones, + ofono_voicecall_cb_t cb, void *data) +{ +} + +static gboolean isi_voicecall_register(gpointer user) +{ + struct ofono_voicecall *call = user; + + ofono_voicecall_register(call); + + return FALSE; +} + +static int isi_voicecall_probe(struct ofono_voicecall *call) +{ + GIsiModem *idx = ofono_voicecall_get_data(call); + struct voicecall_data *data = g_try_new0(struct voicecall_data, 1); + + if (!data) + return -ENOMEM; + + data->client = g_isi_client_create(idx, PN_CALL); + if (!data->client) + return -ENOMEM; + + ofono_voicecall_set_data(call, data); + + return 0; +} + +static int isi_voicecall_remove(struct ofono_voicecall *call) +{ + struct voicecall_data *data = ofono_voicecall_get_data(call); + + if (data) { + g_isi_client_destroy(data->client); + g_free(data); + } + + return 0; +} + +static struct ofono_voicecall_driver driver = { + .name = "isi", + .probe = isi_voicecall_probe, + .remove = isi_voicecall_remove, + .dial = isi_dial, + .answer = isi_answer, + .hangup = isi_hangup, + .list_calls = isi_list_calls, + .hold_all_active = isi_hold_all_active, + .release_all_held = isi_release_all_held, + .set_udub = isi_set_udub, + .release_all_active = isi_release_all_active, + .release_specific = isi_release_specific, + .private_chat = isi_private_chat, + .create_multiparty = isi_create_multiparty, + .transfer = isi_transfer, + .deflect = isi_deflect, + .swap_without_accept = isi_swap_without_accept, + .send_tones = isi_send_tones, +}; + +void isi_voicecall_init() +{ + ofono_voicecall_driver_register(&driver); +} + +void isi_voicecall_exit() +{ + ofono_voicecall_driver_unregister(&driver); +}