Changes in / [434ef65:5287502] in mainline


Ignore:
Location:
uspace
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/usbhub/main.c

    r434ef65 r5287502  
    4242#include "usbhub_private.h"
    4343
    44 /** Hub status-change endpoint description.
    45  *
    46  * For more information see section 11.15.1 of USB 1.1 specification.
    47  */
    48 static usb_endpoint_description_t hub_status_change_endpoint_description = {
     44
     45usb_endpoint_description_t hub_status_change_endpoint_description = {
    4946        .transfer_type = USB_TRANSFER_INTERRUPT,
    5047        .direction = USB_DIRECTION_IN,
    … …  
    6057};
    6158
    62 static usb_endpoint_description_t *usb_hub_endpoints[] = {
    63         &hub_status_change_endpoint_description,
    64         NULL
    65 };
    66 
    6759static usb_driver_t usb_hub_driver = {
    68         .name = NAME,
    69         .ops = &usb_hub_driver_ops,
    70         .endpoints = usb_hub_endpoints
     60        .name = "usbhub",
     61        .ops = &usb_hub_driver_ops
    7162};
    7263
    … …  
    7465int main(int argc, char *argv[])
    7566{
    76         printf(NAME ": HelenOS USB hub driver.\n");
     67        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
     68        usb_log_info("starting hub driver\n");
    7769
    78         usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
    7970       
     71        usb_hub_driver.endpoints = (usb_endpoint_description_t**)
     72                        malloc(2 * sizeof(usb_endpoint_description_t*));
     73        usb_hub_driver.endpoints[0] = &hub_status_change_endpoint_description;
     74        usb_hub_driver.endpoints[1] = NULL;
     75
    8076        return usb_driver_main(&usb_hub_driver);
    8177}

  • uspace/drv/usbhub/usbhub.c

    r434ef65 r5287502  
    157157static int usb_hub_set_configuration(usb_hub_info_t * hub_info){
    158158        //device descriptor
    159         usb_standard_device_descriptor_t *std_descriptor
    160             = &hub_info->usb_device->descriptors.device;
     159        usb_standard_device_descriptor_t std_descriptor;
     160        int opResult = usb_request_get_device_descriptor(
     161                &hub_info->usb_device->ctrl_pipe,
     162            &std_descriptor);
     163        if(opResult!=EOK){
     164                usb_log_error("could not get device descriptor, %d\n",opResult);
     165                return opResult;
     166        }
    161167        usb_log_info("hub has %d configurations\n",
    162             std_descriptor->configuration_count);
    163         if(std_descriptor->configuration_count<1){
     168                        std_descriptor.configuration_count);
     169        if(std_descriptor.configuration_count<1){
    164170                usb_log_error("THERE ARE NO CONFIGURATIONS AVAILABLE\n");
    165171                //shouldn`t I return?
    166                 //definitely
    167                 return EINVAL;
    168         }
    169 
     172        }
     173
     174        /* Retrieve full configuration descriptor. */
     175        uint8_t *descriptors = NULL;
     176        size_t descriptors_size = 0;
     177        opResult = usb_request_get_full_configuration_descriptor_alloc(
     178            &hub_info->usb_device->ctrl_pipe, 0,
     179            (void **) &descriptors, &descriptors_size);
     180        if (opResult != EOK) {
     181                usb_log_error("Could not get configuration descriptor: %s.\n",
     182                    str_error(opResult));
     183                return opResult;
     184        }
    170185        usb_standard_configuration_descriptor_t *config_descriptor
    171             = (usb_standard_configuration_descriptor_t *)
    172             hub_info->usb_device->descriptors.configuration;
     186            = (usb_standard_configuration_descriptor_t *) descriptors;
    173187
    174188        /* Set configuration. */
    175         int opResult = usb_request_set_configuration(
    176             &hub_info->usb_device->ctrl_pipe,
     189        opResult = usb_request_set_configuration(&hub_info->usb_device->ctrl_pipe,
    177190            config_descriptor->configuration_number);
    178191
    … …  
    184197        usb_log_debug("\tused configuration %d\n",
    185198                        config_descriptor->configuration_number);
    186 
     199        free(descriptors);
    187200        return EOK;
    188201}
    … …  
    230243
    231244        /// \TODO what is this?
    232         usb_log_debug("Creating `hub' function.\n");
     245        usb_log_debug("adding to ddf");
    233246        ddf_fun_t *hub_fun = ddf_fun_create(hub_info->usb_device->ddf_dev,
    234247                        fun_exposed, "hub");
    … …  
    244257        fid_t fid = fibril_create(usb_hub_control_loop, hub_info);
    245258        if (fid == 0) {
    246                 usb_log_error("failed to start monitoring fibril for new hub.\n");
     259                usb_log_error("failed to start monitoring fibril for new hub");
    247260                return ENOMEM;
    248261        }
    249262        fibril_add_ready(fid);
    250         usb_log_debug("Hub fibril created.\n");
    251 
    252         usb_log_info("Controlling hub `%s' (%d ports).\n",
    253             hub_info->usb_device->ddf_dev->name, hub_info->port_count);
     263        usb_log_debug("hub fibril created");
     264        usb_log_debug("has %d ports ",hub_info->port_count);
    254265        return EOK;
    255266}
    … …  
    522533        //port reset
    523534        if (usb_port_reset_completed(&status)) {
    524                 usb_log_info("port reset complete\n");
     535                usb_log_info("port reset complete");
    525536                if (usb_port_enabled(&status)) {
    526537                        usb_hub_finalize_add_device(hub, port, usb_port_speed(&status));

  • uspace/drv/usbhub/usbhub.h

    r434ef65 r5287502  
    4646#include <usb/pipes.h>
    4747#include <usb/devdrv.h>
     48
     49
     50/** Hub status-change endpoint description
     51 *
     52 * For more see usb hub specification in 11.15.1 of
     53 */
     54extern usb_endpoint_description_t hub_status_change_endpoint_description;
     55
     56
     57
     58/* Hub endpoints. */
     59/*typedef struct {
     60        usb_pipe_t control;
     61        usb_pipe_t status_change;
     62} usb_hub_endpoints_t;
     63*/
    4864
    4965

  • uspace/lib/usb/include/usb/devdrv.h

    r434ef65 r5287502  
    3838#include <usb/pipes.h>
    3939
    40 /** Descriptors for USB device. */
    41 typedef struct {
    42         /** Standard device descriptor. */
    43         usb_standard_device_descriptor_t device;
    44         /** Full configuration descriptor of current configuration. */
    45         uint8_t *configuration;
    46         size_t configuration_size;
    47 } usb_device_descriptors_t;
    48 
    4940/** USB device structure. */
    5041typedef struct {
    … …  
    6152         */
    6253        int interface_no;
    63 
    64         /** Some useful descriptors. */
    65         usb_device_descriptors_t descriptors;
    66 
    6754        /** Generic DDF device backing this one. */
    6855        ddf_dev_t *ddf_dev;

  • uspace/lib/usb/include/usb/usb.h

    r434ef65 r5287502  
    6161
    6262const char * usb_str_transfer_type(usb_transfer_type_t t);
    63 const char * usb_str_transfer_type_short(usb_transfer_type_t t);
    6463
    6564/** USB data transfer direction. */
    … …  
    7978        USB_SPEED_HIGH
    8079} usb_speed_t;
    81 
    82 const char *usb_str_speed(usb_speed_t);
    83 
    8480
    8581/** USB request type target. */

  • uspace/lib/usb/src/devdrv.c

    r434ef65 r5287502  
    137137        }
    138138
    139         rc = usb_pipe_initialize_from_configuration(dev->pipes, pipe_count,
    140             dev->descriptors.configuration, dev->descriptors.configuration_size,
    141             &dev->wire);
     139        void *config_descriptor;
     140        size_t config_descriptor_size;
     141        rc = usb_request_get_full_configuration_descriptor_alloc(
     142            &dev->ctrl_pipe, 0, &config_descriptor, &config_descriptor_size);
     143        if (rc != EOK) {
     144                usb_log_error("Failed retrieving configuration of `%s': %s.\n",
     145                    dev->ddf_dev->name, str_error(rc));
     146                goto rollback;
     147        }
     148
     149        rc = usb_pipe_initialize_from_configuration(dev->pipes,
     150           pipe_count, config_descriptor, config_descriptor_size, &dev->wire);
    142151        if (rc != EOK) {
    143152                usb_log_error("Failed initializing USB endpoints: %s.\n",
    … …  
    228237
    229238        /*
    230          * For further actions, we need open session on default control pipe.
     239         * Initialization of other pipes requires open session on
     240         * default control pipe.
    231241         */
    232242        rc = usb_pipe_start_session(&dev->ctrl_pipe);
    … …  
    237247        }
    238248
    239         /* Get the device descriptor. */
    240         rc = usb_request_get_device_descriptor(&dev->ctrl_pipe,
    241             &dev->descriptors.device);
    242         if (rc != EOK) {
    243                 usb_log_error("Failed to retrieve device descriptor: %s.\n",
    244                     str_error(rc));
    245                 return rc;
    246         }
    247 
    248         /* Get the full configuration descriptor. */
    249         rc = usb_request_get_full_configuration_descriptor_alloc(
    250             &dev->ctrl_pipe, 0, (void **) &dev->descriptors.configuration,
    251             &dev->descriptors.configuration_size);
    252         if (rc != EOK) {
    253                 usb_log_error("Failed retrieving configuration descriptor: %s.\n",
    254                     dev->ddf_dev->name, str_error(rc));
    255                 return rc;
    256         }
    257 
    258249        if (driver->endpoints != NULL) {
    259250                rc = initialize_other_pipes(driver, dev);
    … …  
    262253        /* No checking here. */
    263254        usb_pipe_end_session(&dev->ctrl_pipe);
    264 
    265         /* Rollback actions. */
    266         if (rc != EOK) {
    267                 if (dev->descriptors.configuration != NULL) {
    268                         free(dev->descriptors.configuration);
    269                 }
    270         }
    271255
    272256        return rc;
    … …  
    299283        dev->ddf_dev->driver_data = dev;
    300284        dev->driver_data = NULL;
    301         dev->descriptors.configuration = NULL;
    302285
    303286        rc = initialize_pipes(dev);

  • uspace/lib/usb/src/host/batch.c

    r434ef65 r5287502  
    107107            instance->buffer_size);
    108108
    109         usb_log_debug("Batch %p done (T%d.%d, %s %s in, %zuB): %s (%d).\n",
    110             instance,
    111             instance->target.address, instance->target.endpoint,
    112             usb_str_speed(instance->speed),
    113             usb_str_transfer_type_short(instance->transfer_type),
    114             instance->transfered_size,
    115             str_error(instance->error), instance->error);
     109        int err = instance->error;
     110        usb_log_debug("Batch(%p) callback IN(type:%d): %s(%d), %zu.\n",
     111            instance, instance->transfer_type, str_error(err), err,
     112            instance->transfered_size);
    116113
    117         instance->callback_in(instance->fun, instance->error,
    118             instance->transfered_size, instance->arg);
     114        instance->callback_in(
     115            instance->fun, err, instance->transfered_size, instance->arg);
    119116}
    120117/*----------------------------------------------------------------------------*/
    … …  
    128125        assert(instance->callback_out);
    129126
    130         usb_log_debug("Batch %p done (T%d.%d, %s %s out): %s (%d).\n",
    131             instance,
    132             instance->target.address, instance->target.endpoint,
    133             usb_str_speed(instance->speed),
    134             usb_str_transfer_type_short(instance->transfer_type),
    135             str_error(instance->error), instance->error);
    136 
     127        int err = instance->error;
     128        usb_log_debug("Batch(%p) callback OUT(type:%d): %s(%d).\n",
     129            instance, instance->transfer_type, str_error(err), err);
    137130        instance->callback_out(instance->fun,
    138             instance->error, instance->arg);
     131            err, instance->arg);
    139132}
    140133/**

  • uspace/lib/usb/src/usb.c

    r434ef65 r5287502  
    3636#include <errno.h>
    3737
    38 #define ARR_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
    39 
    40 static const char *str_speed[] = {
    41         "low",
    42         "full",
    43         "high"
    44 };
    45 
    46 static const char *str_transfer_type[] = {
    47         "control",
    48         "isochronous",
    49         "bulk",
    50         "interrupt"
    51 };
    52 
    53 static const char *str_transfer_type_short[] = {
    54         "ctrl",
    55         "iso",
    56         "bulk",
    57         "intr"
    58 };
    5938
    6039/** String representation for USB transfer type.
    … …  
    6342 * @return Transfer type as a string (in English).
    6443 */
    65 const char *usb_str_transfer_type(usb_transfer_type_t t)
     44const char * usb_str_transfer_type(usb_transfer_type_t t)
    6645{
    67         if (t >= ARR_SIZE(str_transfer_type)) {
    68                 return "invalid";
     46        switch (t) {
     47                case USB_TRANSFER_ISOCHRONOUS:
     48                        return "isochronous";
     49                case USB_TRANSFER_INTERRUPT:
     50                        return "interrupt";
     51                case USB_TRANSFER_CONTROL:
     52                        return "control";
     53                case USB_TRANSFER_BULK:
     54                        return "bulk";
     55                default:
     56                        return "unknown";
    6957        }
    70         return str_transfer_type[t];
    71 }
    72 
    73 /** String representation for USB transfer type (short version).
    74  *
    75  * @param t Transfer type.
    76  * @return Transfer type as a short string for debugging messages.
    77  */
    78 const char *usb_str_transfer_type_short(usb_transfer_type_t t)
    79 {
    80         if (t >= ARR_SIZE(str_transfer_type_short)) {
    81                 return "invl";
    82         }
    83         return str_transfer_type_short[t];
    84 }
    85 
    86 /** String representation of USB speed.
    87  *
    88  * @param s The speed.
    89  * @return USB speed as a string (in English).
    90  */
    91 const char *usb_str_speed(usb_speed_t s)
    92 {
    93         if (s >= ARR_SIZE(str_speed)) {
    94                 return "invalid";
    95         }
    96         return str_speed[s];
    9758}
    9859
Note: See TracChangeset for help on using the changeset viewer.