5 * Copyright (C) 2007-2009 Intel Corporation. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
31 struct connman_device {
32 struct connman_element element;
33 enum connman_device_type type;
34 enum connman_device_mode mode;
35 enum connman_device_policy policy;
42 struct connman_device_driver *driver;
48 static const char *type2description(enum connman_device_type type)
51 case CONNMAN_DEVICE_TYPE_UNKNOWN:
52 case CONNMAN_DEVICE_TYPE_VENDOR:
54 case CONNMAN_DEVICE_TYPE_ETHERNET:
56 case CONNMAN_DEVICE_TYPE_WIFI:
58 case CONNMAN_DEVICE_TYPE_WIMAX:
60 case CONNMAN_DEVICE_TYPE_BLUETOOTH:
62 case CONNMAN_DEVICE_TYPE_HSO:
69 static const char *type2string(enum connman_device_type type)
72 case CONNMAN_DEVICE_TYPE_UNKNOWN:
73 case CONNMAN_DEVICE_TYPE_VENDOR:
75 case CONNMAN_DEVICE_TYPE_ETHERNET:
77 case CONNMAN_DEVICE_TYPE_WIFI:
79 case CONNMAN_DEVICE_TYPE_WIMAX:
81 case CONNMAN_DEVICE_TYPE_BLUETOOTH:
83 case CONNMAN_DEVICE_TYPE_HSO:
90 static const char *policy2string(enum connman_device_policy policy)
93 case CONNMAN_DEVICE_POLICY_UNKNOWN:
95 case CONNMAN_DEVICE_POLICY_IGNORE:
97 case CONNMAN_DEVICE_POLICY_OFF:
99 case CONNMAN_DEVICE_POLICY_AUTO:
101 case CONNMAN_DEVICE_POLICY_MANUAL:
108 static enum connman_device_policy string2policy(const char *policy)
110 if (g_str_equal(policy, "ignore") == TRUE)
111 return CONNMAN_DEVICE_POLICY_IGNORE;
112 else if (g_str_equal(policy, "off") == TRUE)
113 return CONNMAN_DEVICE_POLICY_OFF;
114 else if (g_str_equal(policy, "auto") == TRUE)
115 return CONNMAN_DEVICE_POLICY_AUTO;
116 else if (g_str_equal(policy, "manual") == TRUE)
117 return CONNMAN_DEVICE_POLICY_MANUAL;
119 return CONNMAN_DEVICE_POLICY_UNKNOWN;
122 static int set_powered(struct connman_device *device, gboolean powered)
124 struct connman_device_driver *driver = device->driver;
127 DBG("device %p powered %d", device, powered);
132 if (powered == TRUE) {
134 err = driver->enable(device);
138 g_hash_table_remove_all(device->networks);
141 err = driver->disable(device);
149 static int set_policy(DBusConnection *connection,
150 struct connman_device *device,
151 enum connman_device_policy policy)
154 DBusMessageIter entry, value;
155 const char *str, *key = "Policy";
158 DBG("device %p policy %d", device, policy);
160 if (device->policy == policy)
164 case CONNMAN_DEVICE_POLICY_UNKNOWN:
166 case CONNMAN_DEVICE_POLICY_IGNORE:
168 case CONNMAN_DEVICE_POLICY_OFF:
169 if (device->powered == TRUE)
170 err = set_powered(device, FALSE);
172 case CONNMAN_DEVICE_POLICY_AUTO:
173 case CONNMAN_DEVICE_POLICY_MANUAL:
174 if (device->powered == FALSE)
175 err = set_powered(device, TRUE);
182 device->policy = policy;
184 signal = dbus_message_new_signal(device->element.path,
185 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
189 dbus_message_iter_init_append(signal, &entry);
191 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
193 str = policy2string(policy);
195 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
196 DBUS_TYPE_STRING_AS_STRING, &value);
197 dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &str);
198 dbus_message_iter_close_container(&entry, &value);
200 g_dbus_send_message(connection, signal);
205 static void append_networks(struct connman_device *device,
206 DBusMessageIter *entry)
208 DBusMessageIter value, iter;
209 const char *key = "Networks";
211 dbus_message_iter_append_basic(entry, DBUS_TYPE_STRING, &key);
213 dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
214 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
217 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
218 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
219 __connman_element_list((struct connman_element *) device,
220 CONNMAN_ELEMENT_TYPE_NETWORK, &iter);
221 dbus_message_iter_close_container(&value, &iter);
223 dbus_message_iter_close_container(entry, &value);
226 static DBusMessage *get_properties(DBusConnection *conn,
227 DBusMessage *msg, void *data)
229 struct connman_device *device = data;
231 DBusMessageIter array, dict, entry;
234 DBG("conn %p", conn);
236 reply = dbus_message_new_method_return(msg);
240 dbus_message_iter_init_append(reply, &array);
242 dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
243 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
244 DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
245 DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
247 str = type2description(device->type);
248 if (str != NULL && device->interface != NULL) {
249 char *name = g_strdup_printf("%s (%s)", str, device->interface);
251 connman_dbus_dict_append_variant(&dict, "Name",
252 DBUS_TYPE_STRING, &name);
256 str = type2string(device->type);
258 connman_dbus_dict_append_variant(&dict, "Type",
259 DBUS_TYPE_STRING, &str);
261 if (device->interface != NULL)
262 connman_dbus_dict_append_variant(&dict, "Interface",
263 DBUS_TYPE_STRING, &device->interface);
265 str = policy2string(device->policy);
267 connman_dbus_dict_append_variant(&dict, "Policy",
268 DBUS_TYPE_STRING, &str);
270 connman_dbus_dict_append_variant(&dict, "Powered",
271 DBUS_TYPE_BOOLEAN, &device->powered);
273 if (device->driver && device->driver->scan)
274 connman_dbus_dict_append_variant(&dict, "Scanning",
275 DBUS_TYPE_BOOLEAN, &device->scanning);
277 switch (device->mode) {
278 case CONNMAN_DEVICE_MODE_UNKNOWN:
279 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
281 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
282 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
283 dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY,
285 append_networks(device, &entry);
286 dbus_message_iter_close_container(&dict, &entry);
290 dbus_message_iter_close_container(&array, &dict);
295 static DBusMessage *set_property(DBusConnection *conn,
296 DBusMessage *msg, void *data)
298 struct connman_device *device = data;
299 DBusMessageIter iter, value;
302 DBG("conn %p", conn);
304 if (dbus_message_iter_init(msg, &iter) == FALSE)
305 return __connman_error_invalid_arguments(msg);
307 dbus_message_iter_get_basic(&iter, &name);
308 dbus_message_iter_next(&iter);
309 dbus_message_iter_recurse(&iter, &value);
311 if (__connman_security_check_privileges(msg) < 0)
312 return __connman_error_permission_denied(msg);
314 if (g_str_equal(name, "Powered") == TRUE) {
318 dbus_message_iter_get_basic(&value, &powered);
320 if (device->powered == powered)
321 return __connman_error_invalid_arguments(msg);
323 err = set_powered(device, powered);
324 if (err < 0 && err != -EINPROGRESS)
325 return __connman_error_failed(msg);
326 } else if (g_str_equal(name, "Policy") == TRUE) {
327 enum connman_device_policy policy;
331 dbus_message_iter_get_basic(&value, &str);
332 policy = string2policy(str);
333 if (policy == CONNMAN_DEVICE_POLICY_UNKNOWN)
334 return __connman_error_invalid_arguments(msg);
336 err = set_policy(conn, device, policy);
338 return __connman_error_failed(msg);
341 __connman_element_store(&device->element);
343 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
346 static DBusMessage *create_network(DBusConnection *conn,
347 DBusMessage *msg, void *data)
349 DBG("conn %p", conn);
351 if (__connman_security_check_privileges(msg) < 0)
352 return __connman_error_permission_denied(msg);
354 return __connman_error_invalid_arguments(msg);
357 static DBusMessage *remove_network(DBusConnection *conn,
358 DBusMessage *msg, void *data)
360 DBG("conn %p", conn);
362 if (__connman_security_check_privileges(msg) < 0)
363 return __connman_error_permission_denied(msg);
365 return __connman_error_invalid_arguments(msg);
368 static DBusMessage *propose_scan(DBusConnection *conn,
369 DBusMessage *msg, void *data)
371 struct connman_device *device = data;
374 DBG("conn %p", conn);
376 switch (device->mode) {
377 case CONNMAN_DEVICE_MODE_UNKNOWN:
378 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
379 return __connman_error_not_supported(msg);
380 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
381 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
385 if (!device->driver || !device->driver->scan)
386 return __connman_error_not_supported(msg);
388 err = device->driver->scan(device);
390 return __connman_error_failed(msg);
392 return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
395 static GDBusMethodTable device_methods[] = {
396 { "GetProperties", "", "a{sv}", get_properties },
397 { "SetProperty", "sv", "", set_property },
398 { "CreateNetwork", "a{sv}", "o", create_network },
399 { "RemoveNetwork", "o", "", remove_network },
400 { "ProposeScan", "", "", propose_scan },
404 static GDBusSignalTable device_signals[] = {
405 { "PropertyChanged", "sv" },
409 static DBusConnection *connection;
411 static void append_devices(DBusMessageIter *entry)
413 DBusMessageIter value, iter;
414 const char *key = "Devices";
416 dbus_message_iter_append_basic(entry, DBUS_TYPE_STRING, &key);
418 dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT,
419 DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING,
422 dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
423 DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter);
424 __connman_element_list(NULL, CONNMAN_ELEMENT_TYPE_DEVICE, &iter);
425 dbus_message_iter_close_container(&value, &iter);
427 dbus_message_iter_close_container(entry, &value);
430 static void emit_devices_signal(void)
433 DBusMessageIter entry;
435 signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
436 CONNMAN_MANAGER_INTERFACE, "PropertyChanged");
440 dbus_message_iter_init_append(signal, &entry);
442 append_devices(&entry);
444 g_dbus_send_message(connection, signal);
447 static int register_interface(struct connman_element *element)
449 struct connman_device *device = element->device;
451 DBG("element %p name %s", element, element->name);
453 if (g_dbus_register_interface(connection, element->path,
454 CONNMAN_DEVICE_INTERFACE,
455 device_methods, device_signals,
456 NULL, device, NULL) == FALSE) {
457 connman_error("Failed to register %s device", element->path);
461 emit_devices_signal();
466 static void unregister_interface(struct connman_element *element)
468 DBG("element %p name %s", element, element->name);
470 emit_devices_signal();
472 g_dbus_unregister_interface(connection, element->path,
473 CONNMAN_DEVICE_INTERFACE);
476 static GSList *driver_list = NULL;
478 static gint compare_priority(gconstpointer a, gconstpointer b)
480 const struct connman_device_driver *driver1 = a;
481 const struct connman_device_driver *driver2 = b;
483 return driver2->priority - driver1->priority;
487 * connman_device_driver_register:
488 * @driver: device driver definition
490 * Register a new device driver
492 * Returns: %0 on success
494 int connman_device_driver_register(struct connman_device_driver *driver)
496 DBG("driver %p name %s", driver, driver->name);
498 driver_list = g_slist_insert_sorted(driver_list, driver,
501 //__connman_driver_rescan(&device_driver);
507 * connman_device_driver_unregister:
508 * @driver: device driver definition
510 * Remove a previously registered device driver
512 void connman_device_driver_unregister(struct connman_device_driver *driver)
514 DBG("driver %p name %s", driver, driver->name);
516 driver_list = g_slist_remove(driver_list, driver);
519 static void unregister_network(gpointer data)
521 struct connman_network *network = data;
523 DBG("network %p", network);
525 connman_element_unregister((struct connman_element *) network);
527 connman_network_unref(network);
530 static void device_destruct(struct connman_element *element)
532 struct connman_device *device = element->device;
534 DBG("element %p name %s", element, element->name);
536 g_free(device->path);
537 g_free(device->interface);
539 g_hash_table_destroy(device->networks);
543 * connman_device_create:
544 * @node: device node name (for example an address)
547 * Allocate a new device of given #type and assign the #node name to it.
549 * Returns: a newly-allocated #connman_device structure
551 struct connman_device *connman_device_create(const char *node,
552 enum connman_device_type type)
554 struct connman_device *device;
556 DBG("node %s type %d", node, type);
558 device = g_try_new0(struct connman_device, 1);
562 DBG("device %p", device);
564 device->element.refcount = 1;
566 device->element.name = g_strdup(node);
567 device->element.type = CONNMAN_ELEMENT_TYPE_DEVICE;
568 device->element.index = -1;
571 case CONNMAN_DEVICE_TYPE_UNKNOWN:
572 case CONNMAN_DEVICE_TYPE_VENDOR:
573 case CONNMAN_DEVICE_TYPE_WIFI:
574 case CONNMAN_DEVICE_TYPE_WIMAX:
575 case CONNMAN_DEVICE_TYPE_BLUETOOTH:
576 case CONNMAN_DEVICE_TYPE_HSO:
577 device->element.subtype = CONNMAN_ELEMENT_SUBTYPE_UNKNOWN;
579 case CONNMAN_DEVICE_TYPE_ETHERNET:
580 device->element.subtype = CONNMAN_ELEMENT_SUBTYPE_ETHERNET;
584 device->element.device = device;
585 device->element.destruct = device_destruct;
588 device->mode = CONNMAN_DEVICE_MODE_UNKNOWN;
589 device->policy = CONNMAN_DEVICE_POLICY_AUTO;
591 device->networks = g_hash_table_new_full(g_str_hash, g_str_equal,
592 g_free, unregister_network);
598 * connman_device_ref:
599 * @device: device structure
601 * Increase reference counter of device
603 struct connman_device *connman_device_ref(struct connman_device *device)
605 if (connman_element_ref(&device->element) == NULL)
612 * connman_device_unref:
613 * @device: device structure
615 * Decrease reference counter of device
617 void connman_device_unref(struct connman_device *device)
619 connman_element_unref(&device->element);
623 * connman_device_set_path:
624 * @device: device structure
627 * Set path name of device
629 void connman_device_set_path(struct connman_device *device, const char *path)
631 g_free(device->element.devpath);
632 device->element.devpath = g_strdup(path);
634 g_free(device->path);
635 device->path = g_strdup(path);
639 * connman_device_get_path:
640 * @device: device structure
642 * Get path name of device
644 const char *connman_device_get_path(struct connman_device *device)
650 * connman_device_set_index:
651 * @device: device structure
652 * @index: index number
654 * Set index number of device
656 void connman_device_set_index(struct connman_device *device, int index)
658 device->element.index = index;
662 * connman_device_get_index:
663 * @device: device structure
665 * Get index number of device
667 int connman_device_get_index(struct connman_device *device)
669 return device->element.index;
673 * connman_device_set_interface:
674 * @device: device structure
675 * @interface: interface name
677 * Set interface name of device
679 void connman_device_set_interface(struct connman_device *device,
680 const char *interface)
682 g_free(device->element.devname);
683 device->element.devname = g_strdup(interface);
685 g_free(device->interface);
686 device->interface = g_strdup(interface);
690 * connman_device_get_interface:
691 * @device: device structure
693 * Get interface name of device
695 const char *connman_device_get_interface(struct connman_device *device)
697 return device->interface;
701 * connman_device_set_policy:
702 * @device: device structure
703 * @policy: power and connection policy
705 * Change power and connection policy of device
707 void connman_device_set_policy(struct connman_device *device,
708 enum connman_device_policy policy)
710 device->policy = policy;
714 * connman_device_set_mode:
715 * @device: device structure
716 * @mode: network mode
718 * Change network mode of device
720 void connman_device_set_mode(struct connman_device *device,
721 enum connman_device_mode mode)
727 * connman_device_set_powered:
728 * @device: device structure
729 * @powered: powered state
731 * Change power state of device
733 int connman_device_set_powered(struct connman_device *device,
734 connman_bool_t powered)
737 DBusMessageIter entry, value;
738 const char *key = "Powered";
740 DBG("driver %p powered %d", device, powered);
742 if (device->powered == powered)
745 device->powered = powered;
747 signal = dbus_message_new_signal(device->element.path,
748 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
752 dbus_message_iter_init_append(signal, &entry);
754 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
756 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
757 DBUS_TYPE_BOOLEAN_AS_STRING, &value);
758 dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &powered);
759 dbus_message_iter_close_container(&entry, &value);
761 g_dbus_send_message(connection, signal);
767 * connman_device_set_carrier:
768 * @device: device structure
769 * @carrier: carrier state
771 * Change carrier state of device (only for device without scanning)
773 int connman_device_set_carrier(struct connman_device *device,
774 connman_bool_t carrier)
776 DBG("driver %p carrier %d", device, carrier);
778 switch (device->mode) {
779 case CONNMAN_DEVICE_MODE_UNKNOWN:
780 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
781 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
783 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
787 if (device->carrier == carrier)
790 device->carrier = carrier;
792 if (carrier == TRUE) {
793 struct connman_element *element;
795 element = connman_element_create(NULL);
796 if (element != NULL) {
797 element->type = CONNMAN_ELEMENT_TYPE_DHCP;
798 element->subtype = device->element.subtype;
799 element->index = device->element.index;
801 if (connman_element_register(element,
802 &device->element) < 0)
803 connman_element_unref(element);
806 connman_element_unregister_children(&device->element);
812 * connman_device_set_scanning:
813 * @device: device structure
814 * @scanning: scanning state
816 * Change scanning state of device
818 int connman_device_set_scanning(struct connman_device *device,
819 connman_bool_t scanning)
822 DBusMessageIter entry, value;
823 const char *key = "Scanning";
825 DBG("driver %p scanning %d", device, scanning);
827 if (!device->driver || !device->driver->scan)
830 if (device->scanning == scanning)
833 device->scanning = scanning;
835 signal = dbus_message_new_signal(device->element.path,
836 CONNMAN_DEVICE_INTERFACE, "PropertyChanged");
840 dbus_message_iter_init_append(signal, &entry);
842 dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
844 dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
845 DBUS_TYPE_BOOLEAN_AS_STRING, &value);
846 dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &scanning);
847 dbus_message_iter_close_container(&entry, &value);
849 g_dbus_send_message(connection, signal);
855 * connman_device_add_network:
856 * @device: device structure
857 * @network: network structure
859 * Add new network to the device
861 int connman_device_add_network(struct connman_device *device,
862 struct connman_network *network)
864 const char *identifier = connman_network_get_identifier(network);
867 DBG("device %p network %p", device, network);
869 switch (device->mode) {
870 case CONNMAN_DEVICE_MODE_UNKNOWN:
871 case CONNMAN_DEVICE_MODE_TRANSPORT_IP:
873 case CONNMAN_DEVICE_MODE_NETWORK_SINGLE:
874 case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE:
878 __connman_network_set_device(network, device);
880 err = connman_element_register((struct connman_element *) network,
883 __connman_network_set_device(network, NULL);
887 g_hash_table_insert(device->networks, g_strdup(identifier),
894 * connman_device_get_network:
895 * @device: device structure
896 * @identifier: network identifier
898 * Get network for given identifier
900 struct connman_network *connman_device_get_network(struct connman_device *device,
901 const char *identifier)
903 DBG("device %p identifier %s", device, identifier);
905 return g_hash_table_lookup(device->networks, identifier);
909 * connman_device_remove_network:
910 * @device: device structure
911 * @identifier: network identifier
913 * Remove network for given identifier
915 int connman_device_remove_network(struct connman_device *device,
916 const char *identifier)
918 DBG("device %p identifier %s", device, identifier);
920 g_hash_table_remove(device->networks, identifier);
926 * connman_device_register:
927 * @device: device structure
929 * Register device with the system
931 int connman_device_register(struct connman_device *device)
933 return connman_element_register(&device->element, NULL);
937 * connman_device_unregister:
938 * @device: device structure
940 * Unregister device with the system
942 void connman_device_unregister(struct connman_device *device)
944 connman_element_unregister(&device->element);
948 * connman_device_get_data:
949 * @device: device structure
951 * Get private device data pointer
953 void *connman_device_get_data(struct connman_device *device)
955 return device->driver_data;
959 * connman_device_set_data:
960 * @device: device structure
961 * @data: data pointer
963 * Set private device data pointer
965 void connman_device_set_data(struct connman_device *device, void *data)
967 device->driver_data = data;
970 static void device_enable(struct connman_device *device)
972 DBG("device %p", device);
974 if (device->policy == CONNMAN_DEVICE_POLICY_IGNORE ||
975 device->policy == CONNMAN_DEVICE_POLICY_OFF)
978 if (device->powered == TRUE)
981 if (device->driver->enable)
982 device->driver->enable(device);
985 static void device_disable(struct connman_device *device)
987 DBG("device %p", device);
989 if (device->policy == CONNMAN_DEVICE_POLICY_IGNORE)
992 if (device->powered == FALSE)
995 g_hash_table_remove_all(device->networks);
997 if (device->driver->disable)
998 device->driver->disable(device);
1001 static gboolean match_driver(struct connman_device *device,
1002 struct connman_device_driver *driver)
1004 if (device->type == driver->type ||
1005 driver->type == CONNMAN_DEVICE_TYPE_UNKNOWN)
1011 static int device_probe(struct connman_element *element)
1013 struct connman_device *device = element->device;
1017 DBG("element %p name %s", element, element->name);
1022 for (list = driver_list; list; list = list->next) {
1023 struct connman_device_driver *driver = list->data;
1025 if (match_driver(device, driver) == FALSE)
1028 DBG("driver %p name %s", driver, driver->name);
1030 if (driver->probe(device) == 0) {
1031 device->driver = driver;
1036 if (device->driver == NULL)
1039 err = register_interface(element);
1041 if (device->driver->remove)
1042 device->driver->remove(device);
1046 device_enable(device);
1051 static void device_remove(struct connman_element *element)
1053 struct connman_device *device = element->device;
1055 DBG("element %p name %s", element, element->name);
1060 if (device->driver == NULL)
1063 device_disable(device);
1065 unregister_interface(element);
1067 if (device->driver->remove)
1068 device->driver->remove(device);
1071 static struct connman_driver device_driver = {
1073 .type = CONNMAN_ELEMENT_TYPE_DEVICE,
1074 .priority = CONNMAN_DRIVER_PRIORITY_LOW,
1075 .probe = device_probe,
1076 .remove = device_remove,
1079 int __connman_device_init(void)
1083 connection = connman_dbus_get_connection();
1085 return connman_driver_register(&device_driver);
1088 void __connman_device_cleanup(void)
1092 connman_driver_unregister(&device_driver);
1094 dbus_connection_unref(connection);