Changes in / [652f484:4d20ef7] in mainline


Ignore:
Files:
4 deleted
15 edited

Legend:

Unmodified
Added
Removed
  • .bzrignore

    r652f484 r4d20ef7  
    4949./uspace/app/killall/killall
    5050./uspace/app/klog/klog
    51 ./uspace/app/lsusb/lsusb
    5251./uspace/app/mkfat/mkfat
    5352./uspace/app/netstart/netstart
  • boot/Makefile.common

    r652f484 r4d20ef7  
    128128        $(USPACE_PATH)/app/killall/killall \
    129129        $(USPACE_PATH)/app/mkfat/mkfat \
    130         $(USPACE_PATH)/app/lsusb/lsusb \
    131130        $(USPACE_PATH)/app/sbi/sbi \
    132131        $(USPACE_PATH)/app/redir/redir \
  • uspace/Makefile

    r652f484 r4d20ef7  
    4141        app/killall \
    4242        app/klog \
    43         app/lsusb \
    4443        app/mkfat \
    4544        app/redir \
  • uspace/app/usbinfo/main.c

    r652f484 r4d20ef7  
    4545#include <usb/usbdevice.h>
    4646#include <usb/pipes.h>
    47 #include <usb/host.h>
    4847#include "usbinfo.h"
    49 
    50 static bool try_parse_class_and_address(const char *path,
    51     devman_handle_t *out_hc_handle, usb_address_t *out_device_address)
    52 {
    53         size_t class_index;
    54         size_t address;
    55         int rc;
    56         char *ptr;
    57 
    58         rc = str_size_t(path, &ptr, 10, false, &class_index);
    59         if (rc != EOK) {
    60                 return false;
    61         }
    62         if ((*ptr == ':') || (*ptr == '.')) {
    63                 ptr++;
    64         } else {
    65                 return false;
    66         }
    67         rc = str_size_t(ptr, NULL, 10, true, &address);
    68         if (rc != EOK) {
    69                 return false;
    70         }
    71         rc = usb_ddf_get_hc_handle_by_class(class_index, out_hc_handle);
    72         if (rc != EOK) {
    73                 return false;
    74         }
    75         if (out_device_address != NULL) {
    76                 *out_device_address = (usb_address_t) address;
    77         }
    78         return true;
    79 }
    8048
    8149static bool resolve_hc_handle_and_dev_addr(const char *devpath,
     
    9260        if (str_cmp(devpath, "virt") == 0) {
    9361                devpath = "/virt/usbhc/usb00_a1/usb00_a2";
    94         }
    95 
    96         if (try_parse_class_and_address(devpath,
    97             out_hc_handle, out_device_address)) {
    98                 return true;
    9962        }
    10063
  • uspace/doc/doxygroups.h

    r652f484 r4d20ef7  
    220220
    221221        /**
    222          * @defgroup lsusb HelenOS version of lsusb command
    223          * @ingroup usb
    224          * @brief Application for listing USB host controllers.
    225          * @details
    226          * List all found host controllers.
    227          */
    228 
    229         /**
    230222         * @defgroup drvusbmid USB multi interface device driver
    231223         * @ingroup usb
  • uspace/drv/ehci-hcd/main.c

    r652f484 r4d20ef7  
    9797        }
    9898        hc_fun->ops = &hc_ops;
     99        ret = ddf_fun_bind(hc_fun);
    99100
    100         ret = ddf_fun_bind(hc_fun);
    101101        CHECK_RET_RETURN(ret,
    102102            "Failed to bind EHCI function: %s.\n",
    103             str_error(ret));
    104         ret = ddf_fun_add_to_class(hc_fun, USB_HC_DDF_CLASS_NAME);
    105         CHECK_RET_RETURN(ret,
    106             "Failed to add EHCI to HC class: %s.\n",
    107103            str_error(ret));
    108104
  • uspace/drv/ohci/ohci.c

    r652f484 r4d20ef7  
    185185            "Failed(%d) to bind OHCI device function: %s.\n",
    186186            ret, str_error(ret));
    187         ret = ddf_fun_add_to_class(instance->hc_fun, USB_HC_DDF_CLASS_NAME);
    188         CHECK_RET_DEST_FUN_RETURN(ret,
    189             "Failed to add OHCI to HC class: %s.\n", str_error(ret));
    190 
    191187#undef CHECK_RET_HC_RETURN
    192188
  • uspace/drv/uhci-hcd/uhci.c

    r652f484 r4d20ef7  
    210210            "Failed(%d) to bind UHCI device function: %s.\n",
    211211            ret, str_error(ret));
    212         ret = ddf_fun_add_to_class(instance->hc_fun, USB_HC_DDF_CLASS_NAME);
    213         CHECK_RET_DEST_FUN_RETURN(ret,
    214             "Failed to add UHCI to HC class: %s.\n", str_error(ret));
    215 
    216212#undef CHECK_RET_HC_RETURN
    217213
  • uspace/drv/vhc/main.c

    r652f484 r4d20ef7  
    104104        }
    105105
    106         rc = ddf_fun_add_to_class(hc, USB_HC_DDF_CLASS_NAME);
    107         if (rc != EOK) {
    108                 usb_log_fatal("Failed to add function to HC class: %s.\n",
    109                     str_error(rc));
    110                 free(data);
    111                 return rc;
    112         }
     106        ddf_fun_add_to_class(hc, "usbhc");
    113107
    114108        virtual_hub_device_init(hc);
  • uspace/lib/c/generic/devman.c

    r652f484 r4d20ef7  
    374374}
    375375
    376 int devman_get_device_path(devman_handle_t handle, char *path, size_t path_size)
    377 {
    378         int phone = devman_get_phone(DEVMAN_CLIENT, 0);
    379 
    380         if (phone < 0)
    381                 return phone;
    382 
    383         async_serialize_start();
    384 
    385         ipc_call_t answer;
    386         aid_t req = async_send_1(phone, DEVMAN_DEVICE_GET_DEVICE_PATH,
    387             handle, &answer);
    388 
    389         ipc_call_t data_request_call;
    390         aid_t data_request = async_data_read(phone, path, path_size,
    391             &data_request_call);
    392         if (data_request == 0) {
    393                 async_wait_for(req, NULL);
    394                 async_serialize_end();
    395                 return ENOMEM;
    396         }
    397 
    398         sysarg_t data_request_rc;
    399         sysarg_t opening_request_rc;
    400         async_wait_for(data_request, &data_request_rc);
    401         async_wait_for(req, &opening_request_rc);
    402 
    403         async_serialize_end();
    404 
    405         if (data_request_rc != EOK) {
    406                 /* Prefer the return code of the opening request. */
    407                 if (opening_request_rc != EOK) {
    408                         return (int) opening_request_rc;
    409                 } else {
    410                         return (int) data_request_rc;
    411                 }
    412         }
    413         if (opening_request_rc != EOK) {
    414                 return (int) opening_request_rc;
    415         }
    416 
    417         path[path_size - 1] = 0;
    418 
    419         if (IPC_GET_ARG2(data_request_call) >= path_size) {
    420                 return ELIMIT;
    421         }
    422 
    423         return EOK;
    424 }
    425 
    426376
    427377/** @}
  • uspace/lib/c/include/devman.h

    r652f484 r4d20ef7  
    5555extern int devman_device_get_handle_by_class(const char *, const char *,
    5656    devman_handle_t *, unsigned int);
    57 extern int devman_get_device_path(devman_handle_t, char *, size_t);
    5857
    5958extern int devman_add_device_to_class(devman_handle_t, const char *);
  • uspace/lib/c/include/ipc/devman.h

    r652f484 r4d20ef7  
    149149typedef enum {
    150150        DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD,
    151         DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
    152         DEVMAN_DEVICE_GET_DEVICE_PATH
     151        DEVMAN_DEVICE_GET_HANDLE_BY_CLASS
    153152} client_to_devman_t;
    154153
  • uspace/lib/usb/Makefile

    r652f484 r4d20ef7  
    4646        src/hidparser.c \
    4747        src/hiddescriptor.c \
    48         src/host.c \
    4948        src/hub.c \
    5049        src/pipepriv.c \
  • uspace/lib/usb/include/usb/usb.h

    r652f484 r4d20ef7  
    172172} usb_packet_id;
    173173
    174 /** Class name for USB host controllers. */
    175 #define USB_HC_DDF_CLASS_NAME "usbhc"
    176 
    177174#endif
    178175/**
  • uspace/srv/devman/main.c

    r652f484 r4d20ef7  
    515515}
    516516
    517 /** Find device path by its handle. */
    518 static void devman_get_device_path_by_handle(ipc_callid_t iid,
    519     ipc_call_t *icall)
    520 {
    521         devman_handle_t handle = IPC_GET_ARG1(*icall);
    522 
    523         fun_node_t *fun = find_fun_node(&device_tree, handle);
    524         if (fun == NULL) {
    525                 async_answer_0(iid, ENOMEM);
    526                 return;
    527         }
    528 
    529         ipc_callid_t data_callid;
    530         size_t data_len;
    531         if (!async_data_read_receive(&data_callid, &data_len)) {
    532                 async_answer_0(iid, EINVAL);
    533                 return;
    534         }
    535 
    536         void *buffer = malloc(data_len);
    537         if (buffer == NULL) {
    538                 async_answer_0(data_callid, ENOMEM);
    539                 async_answer_0(iid, ENOMEM);
    540                 return;
    541         }
    542 
    543         size_t sent_length = str_size(fun->pathname);
    544         if (sent_length > data_len) {
    545                 sent_length = data_len;
    546         }
    547 
    548         async_data_read_finalize(data_callid, fun->pathname, sent_length);
    549         async_answer_0(iid, EOK);
    550 
    551         free(buffer);
    552 }
    553 
    554517
    555518/** Function for handling connections from a client to the device manager. */
     
    573536                case DEVMAN_DEVICE_GET_HANDLE_BY_CLASS:
    574537                        devman_function_get_handle_by_class(callid, &call);
    575                         break;
    576                 case DEVMAN_DEVICE_GET_DEVICE_PATH:
    577                         devman_get_device_path_by_handle(callid, &call);
    578538                        break;
    579539                default:
Note: See TracChangeset for help on using the changeset viewer.