Changes in / [76ef94e:d2bff2f] in mainline


Ignore:
Files:
4 deleted
21 edited

Legend:

Unmodified
Added
Removed

  • .bzrignore

    r76ef94e rd2bff2f  
    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

    r76ef94e rd2bff2f  
    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

    r76ef94e rd2bff2f  
    4141        app/killall \
    4242        app/klog \
    43         app/lsusb \
    4443        app/mkfat \
    4544        app/redir \

  • uspace/app/usbinfo/dev.c

    r76ef94e rd2bff2f  
    4040#include "usbinfo.h"
    4141
    42 usbinfo_device_t *prepare_device(const char *name,
    43     devman_handle_t hc_handle, usb_address_t dev_addr)
     42usbinfo_device_t *prepare_device(devman_handle_t hc_handle,
     43    usb_address_t dev_addr)
    4444{
    4545        usbinfo_device_t *dev = malloc(sizeof(usbinfo_device_t));
    … …  
    5555        if (rc != EOK) {
    5656                fprintf(stderr,
    57                     NAME ": failed to create connection to device %s: %s.\n",
    58                     name, str_error(rc));
     57                    NAME ": failed to create connection to the device: %s.\n",
     58                    str_error(rc));
    5959                goto leave;
    6060        }
    … …  
    6464        if (rc != EOK) {
    6565                fprintf(stderr,
    66                     NAME ": failed to create default control pipe to %s: %s.\n",
    67                     name, str_error(rc));
     66                    NAME ": failed to create default control pipe: %s.\n",
     67                    str_error(rc));
    6868                goto leave;
    6969        }
    … …  
    7171        rc = usb_pipe_probe_default_control(&dev->ctrl_pipe);
    7272        if (rc != EOK) {
    73                 if (rc == ENOENT) {
    74                         fprintf(stderr, NAME ": " \
    75                             "device %s not present or malfunctioning.\n",
    76                             name);
    77                 } else {
    78                         fprintf(stderr, NAME ": " \
    79                             "probing default control pipe of %s failed: %s.\n",
    80                             name, str_error(rc));
    81                 }
     73                fprintf(stderr,
     74                    NAME ": probing default control pipe failed: %s.\n",
     75                    str_error(rc));
    8276                goto leave;
    8377        }
    … …  
    9084        if (rc != EOK) {
    9185                fprintf(stderr,
    92                     NAME ": failed to retrieve device descriptor of %s: %s.\n",
    93                     name, str_error(rc));
     86                    NAME ": failed to retrieve device descriptor: %s.\n",
     87                    str_error(rc));
    9488                goto leave;
    9589        }
    … …  
    9993            &dev->full_configuration_descriptor_size);
    10094        if (rc != EOK) {
    101                 fprintf(stderr, NAME ": " \
    102                     "failed to retrieve configuration descriptor of %s: %s.\n",
    103                     name, str_error(rc));
     95                fprintf(stderr,
     96                    NAME ": failed to retrieve configuration descriptor: %s.\n",
     97                    str_error(rc));
    10498                goto leave;
    10599        }

  • uspace/app/usbinfo/main.c

    r76ef94e rd2bff2f  
    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
    … …  
    308271                }
    309272
    310                 usbinfo_device_t *dev = prepare_device(devpath,
    311                     hc_handle, dev_addr);
     273                usbinfo_device_t *dev = prepare_device(hc_handle, dev_addr);
    312274                if (dev == NULL) {
    313275                        continue;

  • uspace/app/usbinfo/usbinfo.h

    r76ef94e rd2bff2f  
    7171}
    7272
    73 usbinfo_device_t *prepare_device(const char *, devman_handle_t, usb_address_t);
     73usbinfo_device_t *prepare_device(devman_handle_t, usb_address_t);
    7474void destroy_device(usbinfo_device_t *);
    7575

  • uspace/doc/doxygroups.h

    r76ef94e rd2bff2f  
    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

    r76ef94e rd2bff2f  
    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

    r76ef94e rd2bff2f  
    230230            ret, str_error(ret));
    231231
    232         ret = ddf_fun_add_to_class(instance->hc_fun, USB_HC_DDF_CLASS_NAME);
    233         CHECK_RET_FINI_RETURN(ret,
    234             "Failed to add OHCI to HC class: %s.\n", str_error(ret));
    235 
    236232        device->driver_data = instance;
    237233

  • uspace/drv/ohci/root_hub.c

    r76ef94e rd2bff2f  
    4545
    4646/**
    47  * standart device descriptor for ohci root hub
     47 *      standart device descriptor for ohci root hub
    4848 */
    4949static const usb_standard_device_descriptor_t ohci_rh_device_descriptor = {
    … …  
    6969 */
    7070static const usb_standard_configuration_descriptor_t ohci_rh_conf_descriptor = {
     71        /// \TODO some values are default or guessed
    7172        .attributes = 1 << 7,
    7273        .configuration_number = 1,
    … …  
    8687        .endpoint_count = 1,
    8788        .interface_class = USB_CLASS_HUB,
     89        /// \TODO is this correct?
    8890        .interface_number = 1,
    8991        .interface_protocol = 0,
    … …  
    105107};
    106108
    107 /**
    108  * bitmask of hub features that are valid to be cleared
    109  */
    110109static const uint32_t hub_clear_feature_valid_mask =
    111     (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) |
     110        (1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER) |
    112111(1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
    113112
    114 /**
    115  * bitmask of hub features that are cleared by writing 1 (and not 0)
    116  */
    117113static const uint32_t hub_clear_feature_by_writing_one_mask =
    118     1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER;
    119 
    120 /**
    121  * bitmask of hub features that are valid to be set
    122  */
     114        1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER;
     115
    123116static const uint32_t hub_set_feature_valid_mask =
    124     (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT) |
     117        (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT) |
    125118(1 << USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
    126119
    127 /**
    128  * bitmask of hub features that are set by writing 1 and cleared by writing 0
    129  */
     120
    130121static const uint32_t hub_set_feature_direct_mask =
    131     (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
    132 
    133 /**
    134  * bitmask of port features that are valid to be set
    135  */
     122        (1 << USB_HUB_FEATURE_C_HUB_OVER_CURRENT);
     123
    136124static const uint32_t port_set_feature_valid_mask =
    137     (1 << USB_HUB_FEATURE_PORT_ENABLE) |
     125        (1 << USB_HUB_FEATURE_PORT_ENABLE) |
    138126(1 << USB_HUB_FEATURE_PORT_SUSPEND) |
    139127(1 << USB_HUB_FEATURE_PORT_RESET) |
    140128(1 << USB_HUB_FEATURE_PORT_POWER);
    141129
    142 /**
    143  * bitmask of port features that can be cleared
    144  */
    145130static const uint32_t port_clear_feature_valid_mask =
    146     (1 << USB_HUB_FEATURE_PORT_CONNECTION) |
     131        (1 << USB_HUB_FEATURE_PORT_CONNECTION) |
    147132(1 << USB_HUB_FEATURE_PORT_SUSPEND) |
    148133(1 << USB_HUB_FEATURE_PORT_OVER_CURRENT) |
    … …  
    156141//USB_HUB_FEATURE_PORT_LOW_SPEED
    157142
    158 /**
    159  * bitmask with port status changes
    160  */
    161143static const uint32_t port_status_change_mask =
    162     (1 << USB_HUB_FEATURE_C_PORT_CONNECTION) |
    163 (1 << USB_HUB_FEATURE_C_PORT_ENABLE) |
    164 (1 << USB_HUB_FEATURE_C_PORT_OVER_CURRENT) |
    165 (1 << USB_HUB_FEATURE_C_PORT_RESET) |
    166 (1 << USB_HUB_FEATURE_C_PORT_SUSPEND);
     144(1<< USB_HUB_FEATURE_C_PORT_CONNECTION) |
     145(1<< USB_HUB_FEATURE_C_PORT_ENABLE) |
     146(1<< USB_HUB_FEATURE_C_PORT_OVER_CURRENT) |
     147(1<< USB_HUB_FEATURE_C_PORT_RESET) |
     148(1<< USB_HUB_FEATURE_C_PORT_SUSPEND);
    167149
    168150
    … …  
    172154
    173155static int process_get_port_status_request(rh_t *instance, uint16_t port,
    174     usb_transfer_batch_t * request);
     156        usb_transfer_batch_t * request);
    175157
    176158static int process_get_hub_status_request(rh_t *instance,
    177     usb_transfer_batch_t * request);
     159        usb_transfer_batch_t * request);
    178160
    179161static int process_get_status_request(rh_t *instance,
    180     usb_transfer_batch_t * request);
     162        usb_transfer_batch_t * request);
    181163
    182164static void create_interrupt_mask_in_instance(rh_t *instance);
    183165
    184166static int process_get_descriptor_request(rh_t *instance,
    185     usb_transfer_batch_t *request);
     167        usb_transfer_batch_t *request);
    186168
    187169static int process_get_configuration_request(rh_t *instance,
    188     usb_transfer_batch_t *request);
     170        usb_transfer_batch_t *request);
    189171
    190172static int process_hub_feature_set_request(rh_t *instance, uint16_t feature);
    191173
    192174static int process_hub_feature_clear_request(rh_t *instance,
    193     uint16_t feature);
     175        uint16_t feature);
    194176
    195177static int process_port_feature_set_request(rh_t *instance,
    196     uint16_t feature, uint16_t port);
     178        uint16_t feature, uint16_t port);
    197179
    198180static int process_port_feature_clear_request(rh_t *instance,
    199     uint16_t feature, uint16_t port);
     181        uint16_t feature, uint16_t port);
    200182
    201183static int process_address_set_request(rh_t *instance,
    202     uint16_t address);
     184        uint16_t address);
    203185
    204186static int process_request_with_output(rh_t *instance,
    205     usb_transfer_batch_t *request);
     187        usb_transfer_batch_t *request);
    206188
    207189static int process_request_with_input(rh_t *instance,
    208     usb_transfer_batch_t *request);
     190        usb_transfer_batch_t *request);
    209191
    210192static int process_request_without_data(rh_t *instance,
    211     usb_transfer_batch_t *request);
     193        usb_transfer_batch_t *request);
    212194
    213195static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request);
    … …  
    216198
    217199static bool is_zeros(void * buffer, size_t size);
     200
     201
    218202
    219203/** Root hub initialization
    … …  
    226210            (instance->registers->rh_desc_a >> RHDA_NDS_SHIFT) & RHDA_NDS_MASK;
    227211        int opResult = rh_init_descriptors(instance);
    228         if (opResult != EOK) {
     212        if(opResult != EOK){
    229213                return opResult;
    230214        }
    … …  
    232216        instance->registers->rh_desc_a |= RHDA_NPS_FLAG;
    233217        instance->unfinished_interrupt_transfer = NULL;
    234         instance->interrupt_mask_size = (instance->port_count + 8) / 8;
     218        instance->interrupt_mask_size = (instance->port_count + 8)/8;
    235219        instance->interrupt_buffer = malloc(instance->interrupt_mask_size);
    236         if (!instance->interrupt_buffer)
     220        if(!instance->interrupt_buffer)
    237221                return ENOMEM;
    238 
    239         usb_log_info("OHCI root hub with %d ports initialized.\n",
    240             instance->port_count);
    241 
     222       
     223
     224        usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
    242225        return EOK;
    243226}
    … …  
    262245                usb_log_info("Root hub got INTERRUPT packet\n");
    263246                create_interrupt_mask_in_instance(instance);
    264                 if (is_zeros(instance->interrupt_buffer,
    265                     instance->interrupt_mask_size)) {
     247                if(is_zeros(instance->interrupt_buffer,
     248                    instance->interrupt_mask_size)){
    266249                        usb_log_debug("no changes..\n");
    267250                        instance->unfinished_interrupt_transfer = request;
    268251                        //will be finished later
    269                 } else {
     252                }else{
    270253                        usb_log_debug("processing changes..\n");
    271254                        process_interrupt_mask_in_instance(instance, request);
    … …  
    273256                opResult = EOK;
    274257        } else {
    275 
    276258                opResult = EINVAL;
    277259                usb_transfer_batch_finish_error(request, opResult);
    … …  
    289271 */
    290272void rh_interrupt(rh_t *instance) {
    291         if (!instance->unfinished_interrupt_transfer) {
     273        if(!instance->unfinished_interrupt_transfer){
    292274                return;
    293275        }
    … …  
    310292static int create_serialized_hub_descriptor(rh_t *instance) {
    311293        size_t size = 7 +
    312             ((instance->port_count + 7) / 8) * 2;
    313         size_t var_size = (instance->port_count + 7) / 8;
     294            ((instance->port_count +7 )/ 8) * 2;
     295        size_t var_size = (instance->port_count +7 )/ 8;
    314296        uint8_t * result = (uint8_t*) malloc(size);
    315         if (!result) return ENOMEM;
     297        if(!result) return ENOMEM;
    316298
    317299        bzero(result, size);
    … …  
    323305        uint32_t hub_desc_reg = instance->registers->rh_desc_a;
    324306        result[3] =
    325             ((hub_desc_reg >> 8) % 2) +
    326             (((hub_desc_reg >> 9) % 2) << 1) +
    327             (((hub_desc_reg >> 10) % 2) << 2) +
    328             (((hub_desc_reg >> 11) % 2) << 3) +
    329             (((hub_desc_reg >> 12) % 2) << 4);
     307                ((hub_desc_reg >> 8) % 2) +
     308                (((hub_desc_reg >> 9) % 2) << 1) +
     309                (((hub_desc_reg >> 10) % 2) << 2) +
     310                (((hub_desc_reg >> 11) % 2) << 3) +
     311                (((hub_desc_reg >> 12) % 2) << 4);
    330312        result[4] = 0;
    331313        result[5] = /*descriptor->pwr_on_2_good_time*/ 50;
    332314        result[6] = 50;
    333315
    334         size_t port;
     316        int port;
    335317        for (port = 1; port <= instance->port_count; ++port) {
    336318                uint8_t is_non_removable =
    337                     instance->registers->rh_desc_b >> port % 2;
     319                        instance->registers->rh_desc_b >> port % 2;
    338320                result[7 + port / 8] +=
    339                     is_non_removable << (port % 8);
     321                        is_non_removable << (port % 8);
    340322        }
    341323        size_t i;
    … …  
    345327        instance->hub_descriptor = result;
    346328        instance->descriptor_size = size;
    347 
    348329        return EOK;
    349330}
    … …  
    359340static int rh_init_descriptors(rh_t *instance) {
    360341        memcpy(&instance->descriptors.device, &ohci_rh_device_descriptor,
    361             sizeof (ohci_rh_device_descriptor)
    362             );
     342                sizeof (ohci_rh_device_descriptor)
     343                );
    363344        usb_standard_configuration_descriptor_t descriptor;
    364345        memcpy(&descriptor, &ohci_rh_conf_descriptor,
    365             sizeof (ohci_rh_conf_descriptor));
     346                sizeof (ohci_rh_conf_descriptor));
    366347
    367348        int opResult = create_serialized_hub_descriptor(instance);
    368         if (opResult != EOK) {
     349        if(opResult != EOK){
    369350                return opResult;
    370351        }
    371352        descriptor.total_length =
    372             sizeof (usb_standard_configuration_descriptor_t) +
    373             sizeof (usb_standard_endpoint_descriptor_t) +
    374             sizeof (usb_standard_interface_descriptor_t) +
    375             instance->descriptor_size;
     353                sizeof (usb_standard_configuration_descriptor_t) +
     354                sizeof (usb_standard_endpoint_descriptor_t) +
     355                sizeof (usb_standard_interface_descriptor_t) +
     356                instance->descriptor_size;
    376357
    377358        uint8_t * full_config_descriptor =
    378             (uint8_t*) malloc(descriptor.total_length);
    379         if (!full_config_descriptor) {
     359                (uint8_t*) malloc(descriptor.total_length);
     360        if(!full_config_descriptor){
    380361                return ENOMEM;
    381362        }
    382363        memcpy(full_config_descriptor, &descriptor, sizeof (descriptor));
    383364        memcpy(full_config_descriptor + sizeof (descriptor),
    384             &ohci_rh_iface_descriptor, sizeof (ohci_rh_iface_descriptor));
     365                &ohci_rh_iface_descriptor, sizeof (ohci_rh_iface_descriptor));
    385366        memcpy(full_config_descriptor + sizeof (descriptor) +
    386             sizeof (ohci_rh_iface_descriptor),
    387             &ohci_rh_ep_descriptor, sizeof (ohci_rh_ep_descriptor));
     367                sizeof (ohci_rh_iface_descriptor),
     368                &ohci_rh_ep_descriptor, sizeof (ohci_rh_ep_descriptor));
    388369        memcpy(full_config_descriptor + sizeof (descriptor) +
    389             sizeof (ohci_rh_iface_descriptor) +
    390             sizeof (ohci_rh_ep_descriptor),
    391             instance->hub_descriptor, instance->descriptor_size);
    392 
     370                sizeof (ohci_rh_iface_descriptor) +
     371                sizeof (ohci_rh_ep_descriptor),
     372                instance->hub_descriptor, instance->descriptor_size);
     373       
    393374        instance->descriptors.configuration = full_config_descriptor;
    394375        instance->descriptors.configuration_size = descriptor.total_length;
    395 
    396376        return EOK;
    397377}
    … …  
    409389 */
    410390static int process_get_port_status_request(rh_t *instance, uint16_t port,
    411     usb_transfer_batch_t * request) {
     391        usb_transfer_batch_t * request) {
    412392        if (port < 1 || port > instance->port_count)
    413393                return EINVAL;
    … …  
    418398        int i;
    419399        for (i = 0; i < instance->port_count; ++i) {
    420 
    421400                usb_log_debug("port status %d,x%x\n",
    422                     instance->registers->rh_port_status[i],
    423                     instance->registers->rh_port_status[i]);
     401                        instance->registers->rh_port_status[i],
     402                        instance->registers->rh_port_status[i]);
    424403        }
    425404#endif
    … …  
    438417 */
    439418static int process_get_hub_status_request(rh_t *instance,
    440     usb_transfer_batch_t * request) {
     419        usb_transfer_batch_t * request) {
    441420        uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
    442421        request->transfered_size = 4;
    … …  
    444423        uint32_t mask = 1 | (1 << 1) | (1 << 16) | (1 << 17);
    445424        uint32_buffer[0] = mask & instance->registers->rh_status;
    446 
    447425        return EOK;
    448426}
    … …  
    459437 */
    460438static int process_get_status_request(rh_t *instance,
    461     usb_transfer_batch_t * request) {
     439        usb_transfer_batch_t * request) {
    462440        size_t buffer_size = request->buffer_size;
    463441        usb_device_request_setup_packet_t * request_packet =
    464             (usb_device_request_setup_packet_t*)
    465             request->setup_buffer;
     442                (usb_device_request_setup_packet_t*)
     443                request->setup_buffer;
    466444
    467445        usb_hub_bm_request_type_t request_type = request_packet->request_type;
    … …  
    475453        if (request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS)
    476454                return process_get_port_status_request(instance,
    477             request_packet->index,
    478             request);
    479 
     455                request_packet->index,
     456                request);
    480457        return ENOTSUP;
    481458}
    … …  
    495472        uint8_t * bitmap = (uint8_t*) (instance->interrupt_buffer);
    496473        uint32_t mask = (1 << (USB_HUB_FEATURE_C_HUB_LOCAL_POWER + 16))
    497             | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
     474                | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
    498475        bzero(bitmap, instance->interrupt_mask_size);
    499476        if (instance->registers->rh_status & mask) {
    500477                bitmap[0] = 1;
    501478        }
    502         size_t port;
     479        int port;
    503480        mask = port_status_change_mask;
    504481        for (port = 1; port <= instance->port_count; ++port) {
    505482                if (mask & instance->registers->rh_port_status[port - 1]) {
    506 
    507483                        bitmap[(port) / 8] += 1 << (port % 8);
    508484                }
    … …  
    521497 */
    522498static int process_get_descriptor_request(rh_t *instance,
    523     usb_transfer_batch_t *request) {
     499        usb_transfer_batch_t *request) {
    524500        usb_device_request_setup_packet_t * setup_request =
    525             (usb_device_request_setup_packet_t*) request->setup_buffer;
     501                (usb_device_request_setup_packet_t*) request->setup_buffer;
    526502        size_t size;
    527503        const void * result_descriptor = NULL;
    … …  
    567543                {
    568544                        usb_log_debug("USB_DESCTYPE_EINVAL %d \n",
    569                             setup_request->value);
     545                                setup_request->value);
    570546                        usb_log_debug("\ttype %d\n\trequest %d\n\tvalue "
    571                             "%d\n\tindex %d\n\tlen %d\n ",
    572                             setup_request->request_type,
    573                             setup_request->request,
    574                             setup_request_value,
    575                             setup_request->index,
    576                             setup_request->length
    577                             );
     547                                "%d\n\tindex %d\n\tlen %d\n ",
     548                                setup_request->request_type,
     549                                setup_request->request,
     550                                setup_request_value,
     551                                setup_request->index,
     552                                setup_request->length
     553                                );
    578554                        return EINVAL;
    579555                }
    … …  
    584560        request->transfered_size = size;
    585561        memcpy(request->data_buffer, result_descriptor, size);
    586 
    587562        return EOK;
    588563}
    … …  
    598573 */
    599574static int process_get_configuration_request(rh_t *instance,
    600     usb_transfer_batch_t *request) {
     575        usb_transfer_batch_t *request) {
    601576        //set and get configuration requests do not have any meaning, only dummy
    602577        //values are returned
    … …  
    605580        request->data_buffer[0] = 1;
    606581        request->transfered_size = 1;
    607 
    608582        return EOK;
    609583}
    … …  
    618592 */
    619593static int process_hub_feature_set_request(rh_t *instance,
    620     uint16_t feature) {
     594        uint16_t feature) {
    621595        if (!((1 << feature) & hub_set_feature_valid_mask))
    622596                return EINVAL;
    623         if (feature == USB_HUB_FEATURE_C_HUB_LOCAL_POWER)
     597        if(feature == USB_HUB_FEATURE_C_HUB_LOCAL_POWER)
    624598                feature = USB_HUB_FEATURE_C_HUB_LOCAL_POWER << 16;
    625599        instance->registers->rh_status =
    626             (instance->registers->rh_status | (1 << feature))
    627             & (~hub_clear_feature_by_writing_one_mask);
    628 
     600                (instance->registers->rh_status | (1 << feature))
     601                & (~hub_clear_feature_by_writing_one_mask);
    629602        return EOK;
    630603}
    … …  
    639612 */
    640613static int process_hub_feature_clear_request(rh_t *instance,
    641     uint16_t feature) {
     614        uint16_t feature) {
    642615        if (!((1 << feature) & hub_clear_feature_valid_mask))
    643616                return EINVAL;
    … …  
    645618        if ((1 << feature) & hub_set_feature_direct_mask) {
    646619                instance->registers->rh_status =
    647                     (instance->registers->rh_status & (~(1 << feature)))
    648                     & (~hub_clear_feature_by_writing_one_mask);
     620                        (instance->registers->rh_status & (~(1 << feature)))
     621                        & (~hub_clear_feature_by_writing_one_mask);
    649622        } else {//the feature is cleared by writing '1'
    650 
    651623                instance->registers->rh_status =
    652                     (instance->registers->rh_status
    653                     & (~hub_clear_feature_by_writing_one_mask))
    654                     | (1 << feature);
     624                        (instance->registers->rh_status
     625                        & (~hub_clear_feature_by_writing_one_mask))
     626                        | (1 << feature);
    655627        }
    656628        return EOK;
    … …  
    668640 */
    669641static int process_port_feature_set_request(rh_t *instance,
    670     uint16_t feature, uint16_t port) {
     642        uint16_t feature, uint16_t port) {
    671643        if (!((1 << feature) & port_set_feature_valid_mask))
    672644                return EINVAL;
    … …  
    674646                return EINVAL;
    675647        instance->registers->rh_port_status[port - 1] =
    676             (instance->registers->rh_port_status[port - 1] | (1 << feature))
    677             & (~port_clear_feature_valid_mask);
     648                (instance->registers->rh_port_status[port - 1] | (1 << feature))
     649                & (~port_clear_feature_valid_mask);
    678650        /// \TODO any error?
    679 
    680651        return EOK;
    681652}
    … …  
    692663 */
    693664static int process_port_feature_clear_request(rh_t *instance,
    694     uint16_t feature, uint16_t port) {
     665        uint16_t feature, uint16_t port) {
    695666        if (!((1 << feature) & port_clear_feature_valid_mask))
    696667                return EINVAL;
    … …  
    702673                feature = USB_HUB_FEATURE_PORT_OVER_CURRENT;
    703674        instance->registers->rh_port_status[port - 1] =
    704             (instance->registers->rh_port_status[port - 1]
    705             & (~port_clear_feature_valid_mask))
    706             | (1 << feature);
     675                (instance->registers->rh_port_status[port - 1]
     676                & (~port_clear_feature_valid_mask))
     677                | (1 << feature);
    707678        /// \TODO any error?
    708 
    709679        return EOK;
    710680}
    … …  
    719689 */
    720690static int process_address_set_request(rh_t *instance,
    721     uint16_t address) {
     691        uint16_t address) {
    722692        instance->address = address;
    723 
    724693        return EOK;
    725694}
    … …  
    736705 */
    737706static int process_request_with_output(rh_t *instance,
    738     usb_transfer_batch_t *request) {
     707        usb_transfer_batch_t *request) {
    739708        usb_device_request_setup_packet_t * setup_request =
    740             (usb_device_request_setup_packet_t*) request->setup_buffer;
     709                (usb_device_request_setup_packet_t*) request->setup_buffer;
    741710        if (setup_request->request == USB_DEVREQ_GET_STATUS) {
    742711                usb_log_debug("USB_DEVREQ_GET_STATUS\n");
    … …  
    749718        if (setup_request->request == USB_DEVREQ_GET_CONFIGURATION) {
    750719                usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n");
    751 
    752720                return process_get_configuration_request(instance, request);
    753721        }
    … …  
    766734 */
    767735static int process_request_with_input(rh_t *instance,
    768     usb_transfer_batch_t *request) {
     736        usb_transfer_batch_t *request) {
    769737        usb_device_request_setup_packet_t * setup_request =
    770             (usb_device_request_setup_packet_t*) request->setup_buffer;
     738                (usb_device_request_setup_packet_t*) request->setup_buffer;
    771739        request->transfered_size = 0;
    772740        if (setup_request->request == USB_DEVREQ_SET_DESCRIPTOR) {
    … …  
    776744                //set and get configuration requests do not have any meaning,
    777745                //only dummy values are returned
    778 
    779746                return EOK;
    780747        }
    … …  
    793760 */
    794761static int process_request_without_data(rh_t *instance,
    795     usb_transfer_batch_t *request) {
     762        usb_transfer_batch_t *request) {
    796763        usb_device_request_setup_packet_t * setup_request =
    797             (usb_device_request_setup_packet_t*) request->setup_buffer;
     764                (usb_device_request_setup_packet_t*) request->setup_buffer;
    798765        request->transfered_size = 0;
    799766        if (setup_request->request == USB_DEVREQ_CLEAR_FEATURE) {
    … …  
    801768                        usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
    802769                        return process_hub_feature_clear_request(instance,
    803                             setup_request->value);
     770                                setup_request->value);
    804771                }
    805772                if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) {
    806773                        usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
    807774                        return process_port_feature_clear_request(instance,
    808                             setup_request->value,
    809                             setup_request->index);
     775                                setup_request->value,
     776                                setup_request->index);
    810777                }
    811778                usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",
    812                     setup_request->request_type);
     779                        setup_request->request_type);
    813780                return EINVAL;
    814781        }
    … …  
    817784                        usb_log_debug("USB_HUB_REQ_TYPE_SET_HUB_FEATURE\n");
    818785                        return process_hub_feature_set_request(instance,
    819                             setup_request->value);
     786                                setup_request->value);
    820787                }
    821788                if (setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE) {
    822789                        usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
    823790                        return process_port_feature_set_request(instance,
    824                             setup_request->value,
    825                             setup_request->index);
     791                                setup_request->value,
     792                                setup_request->index);
    826793                }
    827794                usb_log_debug("USB_HUB_REQ_TYPE_INVALID %d\n",
    828                     setup_request->request_type);
     795                        setup_request->request_type);
    829796                return EINVAL;
    830797        }
    … …  
    832799                usb_log_debug("USB_DEVREQ_SET_ADDRESS\n");
    833800                return process_address_set_request(instance,
    834                     setup_request->value);
     801                        setup_request->value);
    835802        }
    836803        usb_log_debug("USB_DEVREQ_SET_ENOTSUP %d\n",
    837             setup_request->request_type);
    838 
     804                setup_request->request_type);
    839805        return ENOTSUP;
    840806}
    … …  
    870836        }
    871837        usb_log_info("CTRL packet: %s.\n",
    872             usb_debug_str_buffer(
    873             (const uint8_t *) request->setup_buffer, 8, 8));
     838                usb_debug_str_buffer(
     839                (const uint8_t *) request->setup_buffer, 8, 8));
    874840        usb_device_request_setup_packet_t * setup_request =
    875             (usb_device_request_setup_packet_t*)
    876             request->setup_buffer;
     841                (usb_device_request_setup_packet_t*)
     842                request->setup_buffer;
    877843        switch (setup_request->request) {
    878844                case USB_DEVREQ_GET_STATUS:
    … …  
    881847                        usb_log_debug("processing request with output\n");
    882848                        opResult = process_request_with_output(
    883                             instance, request);
     849                                instance, request);
    884850                        break;
    885851                case USB_DEVREQ_CLEAR_FEATURE:
    … …  
    887853                case USB_DEVREQ_SET_ADDRESS:
    888854                        usb_log_debug("processing request without "
    889                             "additional data\n");
     855                                "additional data\n");
    890856                        opResult = process_request_without_data(
    891                             instance, request);
     857                                instance, request);
    892858                        break;
    893859                case USB_DEVREQ_SET_DESCRIPTOR:
    894860                case USB_DEVREQ_SET_CONFIGURATION:
    895861                        usb_log_debug("processing request with "
    896                             "input\n");
     862                                "input\n");
    897863                        opResult = process_request_with_input(
    898                             instance, request);
    899 
     864                                instance, request);
    900865                        break;
    901866                default:
    902867                        usb_log_warning("received unsuported request: "
    903                             "%d\n",
    904                             setup_request->request
    905                             );
     868                                "%d\n",
     869                                setup_request->request
     870                                );
    906871                        opResult = ENOTSUP;
    907872        }
    … …  
    923888 * @return
    924889 */
    925 static int process_interrupt_mask_in_instance(rh_t *instance, usb_transfer_batch_t * request) {
     890static int process_interrupt_mask_in_instance(rh_t *instance, usb_transfer_batch_t * request){
    926891        memcpy(request->data_buffer, instance->interrupt_buffer,
    927892            instance->interrupt_mask_size);
    … …  
    929894        instance->unfinished_interrupt_transfer = NULL;
    930895        usb_transfer_batch_finish_error(request, EOK);
    931 
    932896        return EOK;
    933897}
    … …  
    943907 * @return
    944908 */
    945 static bool is_zeros(void * buffer, size_t size) {
    946         if (!buffer) return true;
    947         if (!size) return true;
     909static bool is_zeros(void * buffer, size_t size){
     910        if(!buffer) return true;
     911        if(!size) return true;
    948912        size_t i;
    949         for (i = 0; i < size; ++i) {
    950                 if (((char*) buffer)[i])
     913        for(i=0;i<size;++i){
     914                if(((char*)buffer)[i])
    951915                        return false;
    952916        }

  • uspace/drv/ohci/root_hub.h

    r76ef94e rd2bff2f  
    5151        usb_address_t address;
    5252        /** hub port count */
    53         size_t port_count;
     53        int port_count;
    5454        /** hubs descriptors */
    5555        usb_device_descriptors_t descriptors;

  • uspace/drv/uhci-hcd/uhci.c

    r76ef94e rd2bff2f  
    264264            ret, str_error(ret));
    265265
    266         ret = ddf_fun_add_to_class(instance->hc_fun, USB_HC_DDF_CLASS_NAME);
    267         CHECK_RET_DEST_FUN_RETURN(ret,
    268             "Failed to add UHCI to HC class: %s.\n", str_error(ret));
    269 
    270266        ret = rh_init(&instance->rh, instance->rh_fun,
    271267            (uintptr_t)instance->hc.registers + 0x10, 4);

  • uspace/drv/usbhub/ports.c

    r76ef94e rd2bff2f  
    5353        size_t port;
    5454        usb_speed_t speed;
    55 };
    56 
    57 /**
    58  * count of port status changes that are not explicitly handled by
    59  * any function here and must be cleared by hand
    60  */
    61 static const unsigned int non_handled_changes_count = 2;
    62 
    63 /**
    64  * port status changes that are not explicitly handled by
    65  * any function here and must be cleared by hand
    66  */
    67 static const int non_handled_changes[] =  {
    68         USB_HUB_FEATURE_C_PORT_ENABLE,
    69         USB_HUB_FEATURE_C_PORT_SUSPEND
    7055};
    7156
    … …  
    146131            &status, USB_HUB_FEATURE_C_PORT_CONNECTION,false);
    147132        usb_port_status_set_bit(
     133            &status, USB_HUB_FEATURE_PORT_RESET,false);
     134        usb_port_status_set_bit(
    148135            &status, USB_HUB_FEATURE_C_PORT_RESET,false);
    149136        usb_port_status_set_bit(
    150137            &status, USB_HUB_FEATURE_C_PORT_OVER_CURRENT,false);
    151        
    152         //clearing not yet handled changes     
    153         unsigned int feature_idx;
    154         for(feature_idx = 0;feature_idx<non_handled_changes_count;
    155             ++feature_idx){
    156                 unsigned int bit_idx = non_handled_changes[feature_idx];
    157                 if(status & (1<<bit_idx)){
    158                         usb_log_info(
    159                             "there was not yet handled change on port %d: %d"
    160                             ";clearing it\n",
    161                         port, bit_idx);
    162                         int opResult = usb_hub_clear_port_feature(
    163                             hub->control_pipe,
    164                             port, bit_idx);
    165                         if (opResult != EOK) {
    166                                 usb_log_warning(
    167                                     "could not clear port flag %d: %d\n",
    168                                     bit_idx, opResult
    169                                     );
    170                         }
    171                         usb_port_status_set_bit(
    172                             &status, bit_idx,false);
    173                 }
    174         }
    175         if(status>>16){
    176                 usb_log_info("there is still some unhandled change %X\n",
    177                     status);
     138        /// \TODO what about port power change?
     139        if (status >> 16) {
     140                usb_log_info("there was unsupported change on port %d: %X\n",
     141                        port, status);
     142
    178143        }
    179144}
    … …  
    257222                    "Port %zu reset complete but port not enabled.\n",
    258223                    (size_t) port);
    259         }
    260         /* Clear the port reset change. */
    261         int rc = usb_hub_clear_port_feature(hub->control_pipe,
    262             port, USB_HUB_FEATURE_C_PORT_RESET);
    263         if (rc != EOK) {
    264                 usb_log_error("Failed to clear port %d reset feature: %s.\n",
    265                     port, str_error(rc));
    266224        }
    267225}
    … …  
    361319        fibril_mutex_unlock(&my_port->reset_mutex);
    362320
     321        /* Clear the port reset change. */
     322        rc = usb_hub_clear_port_feature(hub->control_pipe,
     323            port_no, USB_HUB_FEATURE_C_PORT_RESET);
     324        if (rc != EOK) {
     325                usb_log_error("Failed to clear port %d reset feature: %s.\n",
     326                    port_no, str_error(rc));
     327                return rc;
     328        }
     329
    363330        if (my_port->reset_okay) {
    364331                return EOK;

  • uspace/drv/vhc/main.c

    r76ef94e rd2bff2f  
    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

    r76ef94e rd2bff2f  
    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

    r76ef94e rd2bff2f  
    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

    r76ef94e rd2bff2f  
    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/drv/generic/remote_usbhc.c

    r76ef94e rd2bff2f  
    302302        async_transaction_t *trans = async_transaction_create(callid);
    303303        if (trans == NULL) {
    304                 async_answer_0(data_callid, ENOMEM);
    305304                async_answer_0(callid, ENOMEM);
    306305                return;
    … …  
    315314
    316315        if (rc != EOK) {
    317                 async_answer_0(data_callid, rc);
    318316                async_answer_0(callid, rc);
    319317                async_transaction_destroy(trans);
    … …  
    462460        async_transaction_t *trans = async_transaction_create(callid);
    463461        if (trans == NULL) {
    464                 async_answer_0(data_callid, ENOMEM);
    465462                async_answer_0(callid, ENOMEM);
    466463                free(setup_packet);
    … …  
    472469        trans->buffer = malloc(data_len);
    473470        if (trans->buffer == NULL) {
    474                 async_answer_0(data_callid, ENOMEM);
    475471                async_answer_0(callid, ENOMEM);
    476472                async_transaction_destroy(trans);
    … …  
    484480
    485481        if (rc != EOK) {
    486                 async_answer_0(data_callid, rc);
    487482                async_answer_0(callid, rc);
    488483                async_transaction_destroy(trans);

  • uspace/lib/usb/Makefile

    r76ef94e rd2bff2f  
    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

    r76ef94e rd2bff2f  
    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

    r76ef94e rd2bff2f  
    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.