Index: uspace/app/lsusb/main.c =================================================================== --- uspace/app/lsusb/main.c (revision 12f9f0d0827e1f7c54cf26d56ffabf49e22936f7) +++ uspace/app/lsusb/main.c (revision e280857e4e01465defd530d79811dd788126293a) @@ -50,11 +50,10 @@ #define MAX_USB_ADDRESS USB11_ADDRESS_MAX -#define MAX_FAILED_ATTEMPTS 10 #define MAX_PATH_LENGTH 1024 -static void print_found_hc(size_t class_index, const char *path) +static void print_found_hc(service_id_t sid, const char *path) { // printf(NAME ": host controller %zu is `%s'.\n", class_index, path); - printf("Bus %02zu: %s\n", class_index, path); + printf("Bus %" PRIun ": %s\n", sid, path); } static void print_found_dev(usb_address_t addr, const char *path) @@ -95,13 +94,29 @@ int main(int argc, char *argv[]) { - size_t class_index = 0; - size_t failed_attempts = 0; + category_id_t usbhc_cat; + service_id_t *svcs; + size_t count; + size_t i; + int rc; - while (failed_attempts < MAX_FAILED_ATTEMPTS) { - class_index++; + rc = loc_category_get_id(USB_HC_DDF_CLASS_NAME, &usbhc_cat, 0); + if (rc != EOK) { + printf(NAME ": Error resolving category '%s'", + USB_HC_DDF_CLASS_NAME); + return 1; + } + + rc = loc_category_get_svcs(usbhc_cat, &svcs, &count); + if (rc != EOK) { + printf(NAME ": Error getting list of host controllers.\n"); + return 1; + } + + for (i = 0; i < count; i++) { devman_handle_t hc_handle = 0; - int rc = usb_ddf_get_hc_handle_by_class(class_index, &hc_handle); + int rc = usb_ddf_get_hc_handle_by_sid(svcs[i], &hc_handle); if (rc != EOK) { - failed_attempts++; + printf(NAME ": Error resolving handle of HC with SID %" + PRIun ", skipping.\n", svcs[i]); continue; } @@ -109,9 +124,13 @@ rc = devman_get_device_path(hc_handle, path, MAX_PATH_LENGTH); if (rc != EOK) { + printf(NAME ": Error resolving path of HC with SID %" + PRIun ", skipping.\n", svcs[i]); continue; } - print_found_hc(class_index, path); + print_found_hc(svcs[i], path); print_hc_devices(hc_handle); } + + free(svcs); return 0; Index: uspace/lib/c/generic/devman.c =================================================================== --- uspace/lib/c/generic/devman.c (revision 12f9f0d0827e1f7c54cf26d56ffabf49e22936f7) +++ uspace/lib/c/generic/devman.c (revision e280857e4e01465defd530d79811dd788126293a) @@ -333,5 +333,5 @@ exch = devman_exchange_begin(DEVMAN_CLIENT); if (exch == NULL) - return errno; + return ENOMEM; } @@ -364,59 +364,9 @@ } -int devman_device_get_handle_by_class(const char *classname, - const char *devname, devman_handle_t *handle, unsigned int flags) -{ - async_exch_t *exch; - - if (flags & IPC_FLAG_BLOCKING) - exch = devman_exchange_begin_blocking(DEVMAN_CLIENT); - else { - exch = devman_exchange_begin(DEVMAN_CLIENT); - if (exch == NULL) - return errno; - } - - ipc_call_t answer; - aid_t req = async_send_1(exch, DEVMAN_DEVICE_GET_HANDLE_BY_CLASS, - flags, &answer); - sysarg_t retval = async_data_write_start(exch, classname, - str_size(classname)); - - if (retval != EOK) { - devman_exchange_end(exch); - async_wait_for(req, NULL); - return retval; - } - - retval = async_data_write_start(exch, devname, - str_size(devname)); - - devman_exchange_end(exch); - - if (retval != EOK) { - async_wait_for(req, NULL); - return retval; - } - - async_wait_for(req, &retval); - - if (retval != EOK) { - if (handle != NULL) - *handle = (devman_handle_t) -1; - - return retval; - } - - if (handle != NULL) - *handle = (devman_handle_t) IPC_GET_ARG1(answer); - - return retval; -} - int devman_get_device_path(devman_handle_t handle, char *path, size_t path_size) { async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT); if (exch == NULL) - return errno; + return ENOMEM; ipc_call_t answer; @@ -463,4 +413,17 @@ } +int devman_fun_sid_to_handle(service_id_t sid, devman_handle_t *handle) +{ + async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT); + if (exch == NULL) + return ENOMEM; + + sysarg_t retval = async_req_1_1(exch, DEVMAN_FUN_SID_TO_HANDLE, + sid, handle); + + devman_exchange_end(exch); + return (int) retval; +} + /** @} */ Index: uspace/lib/c/include/devman.h =================================================================== --- uspace/lib/c/include/devman.h (revision 12f9f0d0827e1f7c54cf26d56ffabf49e22936f7) +++ uspace/lib/c/include/devman.h (revision e280857e4e01465defd530d79811dd788126293a) @@ -38,4 +38,5 @@ #include +#include #include #include @@ -56,9 +57,8 @@ extern int devman_device_get_handle(const char *, devman_handle_t *, unsigned int); -extern int devman_device_get_handle_by_class(const char *, const char *, - devman_handle_t *, unsigned int); extern int devman_get_device_path(devman_handle_t, char *, size_t); extern int devman_add_device_to_class(devman_handle_t, const char *); +extern int devman_fun_sid_to_handle(service_id_t, devman_handle_t *); #endif Index: uspace/lib/c/include/ipc/devman.h =================================================================== --- uspace/lib/c/include/ipc/devman.h (revision 12f9f0d0827e1f7c54cf26d56ffabf49e22936f7) +++ uspace/lib/c/include/ipc/devman.h (revision e280857e4e01465defd530d79811dd788126293a) @@ -149,6 +149,6 @@ typedef enum { DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD, - DEVMAN_DEVICE_GET_HANDLE_BY_CLASS, - DEVMAN_DEVICE_GET_DEVICE_PATH + DEVMAN_DEVICE_GET_DEVICE_PATH, + DEVMAN_FUN_SID_TO_HANDLE } client_to_devman_t; Index: uspace/lib/usb/include/usb/hc.h =================================================================== --- uspace/lib/usb/include/usb/hc.h (revision 12f9f0d0827e1f7c54cf26d56ffabf49e22936f7) +++ uspace/lib/usb/include/usb/hc.h (revision e280857e4e01465defd530d79811dd788126293a) @@ -38,4 +38,5 @@ #include #include +#include #include #include @@ -68,5 +69,5 @@ devman_handle_t *); -int usb_ddf_get_hc_handle_by_class(size_t, devman_handle_t *); +int usb_ddf_get_hc_handle_by_sid(service_id_t, devman_handle_t *); Index: uspace/lib/usb/src/hc.c =================================================================== --- uspace/lib/usb/src/hc.c (revision 12f9f0d0827e1f7c54cf26d56ffabf49e22936f7) +++ uspace/lib/usb/src/hc.c (revision e280857e4e01465defd530d79811dd788126293a) @@ -201,32 +201,19 @@ /** Get host controller handle by its class index. * - * @param class_index Class index for the host controller. + * @param sid Service ID of the HC function. * @param hc_handle Where to store the HC handle * (can be NULL for existence test only). * @return Error code. */ -int usb_ddf_get_hc_handle_by_class(size_t class_index, - devman_handle_t *hc_handle) -{ - char *class_index_str; - devman_handle_t hc_handle_tmp; +int usb_ddf_get_hc_handle_by_sid(service_id_t sid, devman_handle_t *hc_handle) +{ + devman_handle_t handle; int rc; - - rc = asprintf(&class_index_str, "%zu", class_index); - if (rc < 0) { - return ENOMEM; - } - rc = devman_device_get_handle_by_class("usbhc", class_index_str, - &hc_handle_tmp, 0); - free(class_index_str); - if (rc != EOK) { - return rc; - } - - if (hc_handle != NULL) { - *hc_handle = hc_handle_tmp; - } - - return EOK; + + rc = devman_fun_sid_to_handle(sid, &handle); + if (hc_handle != NULL) + *hc_handle = handle; + + return rc; } Index: uspace/lib/usb/src/resolve.c =================================================================== --- uspace/lib/usb/src/resolve.c (revision 12f9f0d0827e1f7c54cf26d56ffabf49e22936f7) +++ uspace/lib/usb/src/resolve.c (revision e280857e4e01465defd530d79811dd788126293a) @@ -46,10 +46,10 @@ devman_handle_t *out_hc_handle, usb_address_t *out_device_address) { - size_t class_index; + uint64_t sid; size_t address; int rc; char *ptr; - rc = str_size_t(path, &ptr, 10, false, &class_index); + rc = str_uint64(path, &ptr, 10, false, &sid); if (rc != EOK) { return false; @@ -64,5 +64,5 @@ return false; } - rc = usb_ddf_get_hc_handle_by_class(class_index, out_hc_handle); + rc = usb_ddf_get_hc_handle_by_sid(sid, out_hc_handle); if (rc != EOK) { return false; Index: uspace/srv/devman/devman.c =================================================================== --- uspace/srv/devman/devman.c (revision 12f9f0d0827e1f7c54cf26d56ffabf49e22936f7) +++ uspace/srv/devman/devman.c (revision e280857e4e01465defd530d79811dd788126293a) @@ -73,14 +73,4 @@ } -static int loc_devices_class_compare(unsigned long key[], hash_count_t keys, - link_t *item) -{ - dev_class_info_t *class_info - = hash_table_get_instance(item, dev_class_info_t, loc_link); - assert(class_info != NULL); - - return (class_info->service_id == (service_id_t) key[0]); -} - static void devices_remove_callback(link_t *item) { @@ -102,10 +92,4 @@ .hash = devices_hash, .compare = loc_functions_compare, - .remove_callback = devices_remove_callback -}; - -static hash_table_operations_t loc_devices_class_ops = { - .hash = devices_hash, - .compare = loc_devices_class_compare, .remove_callback = devices_remove_callback }; @@ -950,5 +934,4 @@ link_initialize(&res->dev_functions); list_initialize(&res->match_ids.ids); - list_initialize(&res->classes); link_initialize(&res->devman_fun); link_initialize(&res->loc_fun); @@ -1193,34 +1176,4 @@ } -/** Find function node by its class name and index. */ -fun_node_t *find_fun_node_by_class(class_list_t *class_list, - const char *class_name, const char *dev_name) -{ - assert(class_list != NULL); - assert(class_name != NULL); - assert(dev_name != NULL); - - fibril_rwlock_read_lock(&class_list->rwlock); - - dev_class_t *cl = find_dev_class_no_lock(class_list, class_name); - if (cl == NULL) { - fibril_rwlock_read_unlock(&class_list->rwlock); - return NULL; - } - - dev_class_info_t *dev = find_dev_in_class(cl, dev_name); - if (dev == NULL) { - fibril_rwlock_read_unlock(&class_list->rwlock); - return NULL; - } - - fun_node_t *fun = dev->fun; - - fibril_rwlock_read_unlock(&class_list->rwlock); - - return fun; -} - - /** Find child function node with a specified name. * @@ -1235,187 +1188,4 @@ return find_fun_node_in_device(pfun->child, name); } - -/* Device classes */ - -/** Create device class. - * - * @return Device class. - */ -dev_class_t *create_dev_class(void) -{ - dev_class_t *cl; - - cl = (dev_class_t *) malloc(sizeof(dev_class_t)); - if (cl != NULL) { - memset(cl, 0, sizeof(dev_class_t)); - list_initialize(&cl->devices); - fibril_mutex_initialize(&cl->mutex); - } - - return cl; -} - -/** Create device class info. - * - * @return Device class info. - */ -dev_class_info_t *create_dev_class_info(void) -{ - dev_class_info_t *info; - - info = (dev_class_info_t *) malloc(sizeof(dev_class_info_t)); - if (info != NULL) { - memset(info, 0, sizeof(dev_class_info_t)); - link_initialize(&info->dev_classes); - link_initialize(&info->loc_link); - link_initialize(&info->link); - } - - return info; -} - -size_t get_new_class_dev_idx(dev_class_t *cl) -{ - size_t dev_idx; - - fibril_mutex_lock(&cl->mutex); - dev_idx = ++cl->curr_dev_idx; - fibril_mutex_unlock(&cl->mutex); - - return dev_idx; -} - - -/** Create unique device name within the class. - * - * @param cl The class. - * @param base_dev_name Contains the base name for the device if it was - * specified by the driver when it registered the device by - * the class; NULL if driver specified no base name. - * @return The unique name for the device within the class. - */ -char *create_dev_name_for_class(dev_class_t *cl, const char *base_dev_name) -{ - char *dev_name; - const char *base_name; - - if (base_dev_name != NULL) - base_name = base_dev_name; - else - base_name = cl->base_dev_name; - - size_t idx = get_new_class_dev_idx(cl); - asprintf(&dev_name, "%s%zu", base_name, idx); - - return dev_name; -} - -/** Add the device function to the class. - * - * The device may be added to multiple classes and a class may contain multiple - * devices. The class and the device are associated with each other by the - * dev_class_info_t structure. - * - * @param dev The device. - * @param class The class. - * @param base_dev_name The base name of the device within the class if - * specified by the driver, NULL otherwise. - * @return dev_class_info_t structure which associates the device - * with the class. - */ -dev_class_info_t *add_function_to_class(fun_node_t *fun, dev_class_t *cl, - const char *base_dev_name) -{ - dev_class_info_t *info; - - assert(fun != NULL); - assert(cl != NULL); - - info = create_dev_class_info(); - - - if (info != NULL) { - info->dev_class = cl; - info->fun = fun; - - /* Add the device to the class. */ - fibril_mutex_lock(&cl->mutex); - list_append(&info->link, &cl->devices); - fibril_mutex_unlock(&cl->mutex); - - /* Add the class to the device. */ - list_append(&info->dev_classes, &fun->classes); - - /* Create unique name for the device within the class. */ - info->dev_name = create_dev_name_for_class(cl, base_dev_name); - } - - return info; -} - -dev_class_t *get_dev_class(class_list_t *class_list, char *class_name) -{ - dev_class_t *cl; - - fibril_rwlock_write_lock(&class_list->rwlock); - cl = find_dev_class_no_lock(class_list, class_name); - if (cl == NULL) { - cl = create_dev_class(); - if (cl != NULL) { - cl->name = class_name; - cl->base_dev_name = ""; - add_dev_class_no_lock(class_list, cl); - } - } - - fibril_rwlock_write_unlock(&class_list->rwlock); - return cl; -} - -dev_class_t *find_dev_class_no_lock(class_list_t *class_list, - const char *class_name) -{ - dev_class_t *cl; - - list_foreach(class_list->classes, link) { - cl = list_get_instance(link, dev_class_t, link); - if (str_cmp(cl->name, class_name) == 0) { - return cl; - } - } - - return NULL; -} - -void add_dev_class_no_lock(class_list_t *class_list, dev_class_t *cl) -{ - list_append(&cl->link, &class_list->classes); -} - -dev_class_info_t *find_dev_in_class(dev_class_t *dev_class, const char *dev_name) -{ - assert(dev_class != NULL); - assert(dev_name != NULL); - - list_foreach(dev_class->devices, link) { - dev_class_info_t *dev = list_get_instance(link, - dev_class_info_t, link); - - if (str_cmp(dev->dev_name, dev_name) == 0) { - return dev; - } - } - - return NULL; -} - -void init_class_list(class_list_t *class_list) -{ - list_initialize(&class_list->classes); - fibril_rwlock_initialize(&class_list->rwlock); - hash_table_create(&class_list->loc_functions, DEVICE_BUCKETS, 1, - &loc_devices_class_ops); -} - /* loc devices */ @@ -1436,35 +1206,4 @@ } -fun_node_t *find_loc_class_function(class_list_t *classes, - service_id_t service_id) -{ - fun_node_t *fun = NULL; - dev_class_info_t *cli; - link_t *link; - unsigned long key = (unsigned long)service_id; - - fibril_rwlock_read_lock(&classes->rwlock); - link = hash_table_find(&classes->loc_functions, &key); - if (link != NULL) { - cli = hash_table_get_instance(link, dev_class_info_t, - loc_link); - fun = cli->fun; - } - fibril_rwlock_read_unlock(&classes->rwlock); - - return fun; -} - -void class_add_loc_function(class_list_t *class_list, dev_class_info_t *cli) -{ - unsigned long key = (unsigned long) cli->service_id; - - fibril_rwlock_write_lock(&class_list->rwlock); - hash_table_insert(&class_list->loc_functions, &key, &cli->loc_link); - fibril_rwlock_write_unlock(&class_list->rwlock); - - assert(find_loc_class_function(class_list, cli->service_id) != NULL); -} - void tree_add_loc_function(dev_tree_t *tree, fun_node_t *fun) { Index: uspace/srv/devman/devman.h =================================================================== --- uspace/srv/devman/devman.h (revision 12f9f0d0827e1f7c54cf26d56ffabf49e22936f7) +++ uspace/srv/devman/devman.h (revision e280857e4e01465defd530d79811dd788126293a) @@ -53,5 +53,4 @@ #define DEVICE_BUCKETS 256 -#define LOC_CLASS_NAMESPACE "class" #define LOC_DEVICE_NAMESPACE "devices" #define LOC_SEPARATOR '\\' @@ -170,6 +169,4 @@ match_id_list_t match_ids; - /** List of device classes to which this device function belongs. */ - list_t classes; /** Service ID if the device function is registered with loc. */ service_id_t service_id; @@ -213,82 +210,4 @@ hash_table_t loc_functions; } dev_tree_t; - -typedef struct dev_class { - /** The name of the class. */ - const char *name; - - /** - * Pointer to the previous and next class in the list of registered - * classes. - */ - link_t link; - - /** - * List of dev_class_info structures - one for each device registered by - * this class. - */ - list_t devices; - - /** - * Default base name for the device within the class, might be overrided - * by the driver. - */ - const char *base_dev_name; - - /** Unique numerical identifier of the newly added device. */ - size_t curr_dev_idx; - /** Synchronize access to the list of devices in this class. */ - fibril_mutex_t mutex; -} dev_class_t; - -/** - * Provides n-to-m mapping between function nodes and classes - each function - * can register in an arbitrary number of classes and each class can contain - * an arbitrary number of device functions. - */ -typedef struct dev_class_info { - /** The class. */ - dev_class_t *dev_class; - /** The device. */ - fun_node_t *fun; - - /** - * Pointer to the previous and next class info in the list of devices - * registered by the class. - */ - link_t link; - - /** - * Pointer to the previous and next class info in the list of classes - * by which the device is registered. - */ - link_t dev_classes; - - /** The name of the device function within the class. */ - char *dev_name; - /** Service ID in the class namespace. */ - service_id_t service_id; - - /** - * Link to hash table of services registered with location service using - * their class names. - */ - link_t loc_link; -} dev_class_info_t; - -/** The list of device classes. */ -typedef struct class_list { - /** List of classes. */ - list_t classes; - - /** - * Hash table of services registered with location service using their - * class name, indexed by service IDs. - */ - hash_table_t loc_functions; - - /** Fibril mutex for list of classes. */ - fibril_rwlock_t rwlock; -} class_list_t; /* Match ids and scores */ @@ -339,5 +258,4 @@ extern fun_node_t *find_fun_node_by_path(dev_tree_t *, char *); extern fun_node_t *find_fun_node_in_device(dev_node_t *, const char *); -extern fun_node_t *find_fun_node_by_class(class_list_t *, const char *, const char *); /* Device tree */ @@ -348,20 +266,4 @@ extern bool insert_fun_node(dev_tree_t *, fun_node_t *, char *, dev_node_t *); -/* Device classes */ - -extern dev_class_t *create_dev_class(void); -extern dev_class_info_t *create_dev_class_info(void); -extern size_t get_new_class_dev_idx(dev_class_t *); -extern char *create_dev_name_for_class(dev_class_t *, const char *); -extern dev_class_info_t *add_function_to_class(fun_node_t *, dev_class_t *, - const char *); - -extern void init_class_list(class_list_t *); - -extern dev_class_t *get_dev_class(class_list_t *, char *); -extern dev_class_t *find_dev_class_no_lock(class_list_t *, const char *); -extern dev_class_info_t *find_dev_in_class(dev_class_t *, const char *); -extern void add_dev_class_no_lock(class_list_t *, dev_class_t *); - /* Loc services */ @@ -369,7 +271,5 @@ extern fun_node_t *find_loc_tree_function(dev_tree_t *, service_id_t); -extern fun_node_t *find_loc_class_function(class_list_t *, service_id_t); - -extern void class_add_loc_function(class_list_t *, dev_class_info_t *); + extern void tree_add_loc_function(dev_tree_t *, fun_node_t *); Index: uspace/srv/devman/main.c =================================================================== --- uspace/srv/devman/main.c (revision 12f9f0d0827e1f7c54cf26d56ffabf49e22936f7) +++ uspace/srv/devman/main.c (revision e280857e4e01465defd530d79811dd788126293a) @@ -64,5 +64,4 @@ static driver_list_t drivers_list; static dev_tree_t device_tree; -static class_list_t class_list; /** Register running driver. */ @@ -333,30 +332,4 @@ } -static void loc_register_class_dev(dev_class_info_t *cli) -{ - /* Create loc path and name for the service. */ - char *loc_pathname = NULL; - - asprintf(&loc_pathname, "%s/%s%c%s", LOC_CLASS_NAMESPACE, - cli->dev_class->name, LOC_SEPARATOR, cli->dev_name); - if (loc_pathname == NULL) - return; - - /* - * Register the device with location service and remember its - * service ID. - */ - loc_service_register_with_iface(loc_pathname, - &cli->service_id, DEVMAN_CONNECT_FROM_LOC); - - /* - * Add device to the hash map of class devices registered with - * location service. - */ - class_add_loc_function(&class_list, cli); - - free(loc_pathname); -} - static void devman_add_function_to_class(ipc_callid_t callid, ipc_call_t *call) { @@ -380,10 +353,4 @@ } - dev_class_t *cl = get_dev_class(&class_list, class_name); - dev_class_info_t *class_info = add_function_to_class(fun, cl, NULL); - - /* Register the device's class alias with location service. */ - loc_register_class_dev(class_info); - rc = loc_category_get_id(class_name, &cat_id, IPC_FLAG_BLOCKING); if (rc == EOK) { @@ -394,6 +361,6 @@ } - log_msg(LVL_NOTE, "Function `%s' added to class `%s' as `%s'.", - fun->pathname, class_name, class_info->dev_name); + log_msg(LVL_NOTE, "Function `%s' added to class `%s'.", + fun->pathname, class_name); async_answer_0(callid, EOK); @@ -483,38 +450,4 @@ } -/** Find handle for the device instance identified by device class name. */ -static void devman_function_get_handle_by_class(ipc_callid_t iid, - ipc_call_t *icall) -{ - char *classname; - char *devname; - - int rc = async_data_write_accept((void **) &classname, true, 0, 0, 0, 0); - if (rc != EOK) { - async_answer_0(iid, rc); - return; - } - rc = async_data_write_accept((void **) &devname, true, 0, 0, 0, 0); - if (rc != EOK) { - free(classname); - async_answer_0(iid, rc); - return; - } - - - fun_node_t *fun = find_fun_node_by_class(&class_list, - classname, devname); - - free(classname); - free(devname); - - if (fun == NULL) { - async_answer_0(iid, ENOENT); - return; - } - - async_answer_1(iid, EOK, fun->handle); -} - /** Find device path by its handle. */ static void devman_get_device_path_by_handle(ipc_callid_t iid, @@ -554,4 +487,18 @@ } +/** Find handle for the function instance identified by its service ID. */ +static void devman_fun_sid_to_handle(ipc_callid_t iid, ipc_call_t *icall) +{ + fun_node_t *fun; + + fun = find_loc_tree_function(&device_tree, IPC_GET_ARG1(*icall)); + + if (fun == NULL) { + async_answer_0(iid, ENOENT); + return; + } + + async_answer_1(iid, EOK, fun->handle); +} /** Function for handling connections from a client to the device manager. */ @@ -572,9 +519,9 @@ devman_function_get_handle(callid, &call); break; - case DEVMAN_DEVICE_GET_HANDLE_BY_CLASS: - devman_function_get_handle_by_class(callid, &call); - break; case DEVMAN_DEVICE_GET_DEVICE_PATH: devman_get_device_path_by_handle(callid, &call); + break; + case DEVMAN_FUN_SID_TO_HANDLE: + devman_fun_sid_to_handle(callid, &call); break; default: @@ -678,6 +625,4 @@ fun = find_loc_tree_function(&device_tree, service_id); - if (fun == NULL) - fun = find_loc_class_function(&class_list, service_id); if (fun == NULL || fun->dev->drv == NULL) { @@ -750,6 +695,4 @@ } - init_class_list(&class_list); - /* * !!! devman_connection ... as the device manager is not a real loc Index: uspace/srv/loc/loc.c =================================================================== --- uspace/srv/loc/loc.c (revision 12f9f0d0827e1f7c54cf26d56ffabf49e22936f7) +++ uspace/srv/loc/loc.c (revision e280857e4e01465defd530d79811dd788126293a) @@ -1203,4 +1203,7 @@ categ_dir_add_cat(&cdir, cat); + cat = category_new("usbhc"); + categ_dir_add_cat(&cdir, cat); + return true; }