int __connman_technology_add_device(struct connman_device *device)
{
struct connman_technology *technology;
enum connman_service_type type;
type = __connman_device_get_service_type(device);
DBG("device %p type %s", device, get_name(type));
technology = technology_get(type);
if (technology == NULL) {
/*
* Since no driver can be found for this device at the moment we
* add it to the techless device list.
*/
techless_device_list = g_slist_prepend(techless_device_list,
device);
return -ENXIO;
}
__sync_synchronize();
if (technology->rfkill_driven == TRUE) {
if (technology->enabled == TRUE && global_offlinemode == FALSE)
__connman_device_enable(device);
else
__connman_device_disable(device);
goto done;
}
if (technology->enable_persistent == TRUE &&
global_offlinemode == FALSE) {
int err = __connman_device_enable(device);
/*
* connman_technology_add_device() calls __connman_device_enable()
* but since the device is already enabled, the calls does not
* propagate through to connman_technology_enabled via
* connman_device_set_powered.
*/
if (err == -EALREADY)
__connman_technology_enabled(type);
}
/* if technology persistent state is offline */
if (technology->enable_persistent == FALSE)
__connman_device_disable(device);
done:
technology->device_list = g_slist_prepend(technology->device_list,
device);
return 0;
}
int __connman_technology_add_device(struct connman_device *device)
{
struct connman_technology *technology;
enum connman_service_type type;
DBG("device %p", device);
type = __connman_device_get_service_type(device);
__connman_notifier_register(type);
technology = technology_get(type);
if (technology == NULL)
return -ENXIO;
if (technology->enable_persistent && !global_offlinemode)
__connman_device_enable(device);
/* if technology persistent state is offline */
if (!technology->enable_persistent)
__connman_device_disable(device);
technology->device_list = g_slist_append(technology->device_list,
device);
return 0;
}
static int set_powered(struct connman_device *device, connman_bool_t powered)
{
DBG("device %p powered %d", device, powered);
if (powered == TRUE)
return __connman_device_enable(device);
else
return __connman_device_disable(device);
}
static int setup_device(struct connman_device *device)
{
DBG("device %p", device);
__connman_technology_add_device(device);
if (device->offlinemode == FALSE &&
device->powered_persistent == TRUE)
__connman_device_enable(device);
return 0;
}
static int technology_affect_devices(struct connman_technology *technology,
connman_bool_t enable_device)
{
GSList *list;
int err = 0;
for (list = technology->device_list; list; list = list->next) {
struct connman_device *device = list->data;
if (enable_device == TRUE)
err = __connman_device_enable(device);
else
err = __connman_device_disable(device);
}
return err;
}
/**
* connman_device_set_powered:
* @device: device structure
* @powered: powered state
*
* Change power state of device
*/
int connman_device_set_powered(struct connman_device *device,
connman_bool_t powered)
{
int err;
enum connman_service_type type;
DBG("driver %p powered %d", device, powered);
if (device->powered == powered) {
device->powered_pending = powered;
return -EALREADY;
}
if (powered == TRUE)
err = __connman_device_enable(device);
else
err = __connman_device_disable(device);
if (err < 0 && err != -EINPROGRESS && err != -EALREADY)
return err;
device->powered = powered;
device->powered_pending = powered;
type = __connman_device_get_service_type(device);
if (device->powered == TRUE)
__connman_technology_enable(type);
else
__connman_technology_disable(type);
if (device->offlinemode == TRUE && powered == TRUE)
return connman_device_set_powered(device, FALSE);
if (powered == FALSE)
return 0;
reset_scan_trigger(device);
if (device->driver && device->driver->scan)
device->driver->scan(device);
return 0;
}
int __connman_device_enable_persistent(struct connman_device *device)
{
int err;
DBG("device %p", device);
device->powered_persistent = TRUE;
__connman_storage_save_device(device);
err = __connman_device_enable(device);
if (err == 0 || err == -EINPROGRESS) {
device->offlinemode = FALSE;
if (__connman_profile_get_offlinemode() == TRUE) {
__connman_profile_set_offlinemode(FALSE, FALSE);
__connman_profile_save_default();
}
}
return err;
}
int __connman_technology_enable(enum connman_service_type type, DBusMessage *msg)
{
struct connman_technology *technology;
GSList *list;
int err = 0;
int ret = -ENODEV;
DBusMessage *reply;
DBG("type %d enable", type);
technology = technology_find(type);
if (technology == NULL) {
err = -ENXIO;
goto done;
}
if (technology->pending_reply != NULL) {
err = -EBUSY;
goto done;
}
if (msg != NULL) {
/*
* This is a bit of a trick. When msg is not NULL it means
* thats technology_enable was invoked from the manager API. Hence we save
* the state here.
*/
technology->enable_persistent = TRUE;
save_state(technology);
}
__connman_rfkill_block(technology->type, FALSE);
/*
* An empty device list means that devices in the technology
* were rfkill blocked. The unblock above will enable the devs.
*/
if (technology->device_list == NULL)
return 0;
for (list = technology->device_list; list; list = list->next) {
struct connman_device *device = list->data;
err = __connman_device_enable(device);
/*
* err = 0 : Device was enabled right away.
* If atleast one device gets enabled, we consider
* the technology to be enabled.
*/
if (err == 0)
ret = 0;
}
done:
if (ret == 0) {
if (msg != NULL)
g_dbus_send_reply(connection, msg, DBUS_TYPE_INVALID);
return ret;
}
if (msg != NULL) {
if (err == -EINPROGRESS) {
technology->pending_reply = dbus_message_ref(msg);
technology->pending_timeout = g_timeout_add_seconds(10,
technology_pending_reply, technology);
} else {
reply = __connman_error_failed(msg, -err);
if (reply != NULL)
g_dbus_send_message(connection, reply);
}
}
return err;
}
