Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/usbhub/usbhub.c

    r361fcec r46e078a  
    4545#include <usb/request.h>
    4646#include <usb/classes/hub.h>
    47 #include <usb/devpoll.h>
    4847#include <stdio.h>
    4948
     
    7271static void usb_hub_process_global_interrupt(usb_hub_info_t * hub_info);
    7372
     73
     74/// \TODO malloc checking
    7475
    7576//*********************************************
     
    103104        }
    104105
     106        usb_pipe_start_session(hub_info->control_pipe);
    105107        //set hub configuration
    106108        opResult = usb_hub_set_configuration(hub_info);
     
    119121                return opResult;
    120122        }
    121 
    122         usb_log_debug("Creating 'hub' function in DDF.\n");
     123        usb_pipe_end_session(hub_info->control_pipe);
     124
     125        /// \TODO what is this?
     126        usb_log_debug("Creating `hub' function.\n");
    123127        ddf_fun_t *hub_fun = ddf_fun_create(hub_info->usb_device->ddf_dev,
    124128            fun_exposed, "hub");
     
    148152bool hub_port_changes_callback(usb_device_t *dev,
    149153    uint8_t *change_bitmap, size_t change_bitmap_size, void *arg) {
    150         usb_log_debug("hub_port_changes_callback\n");
    151154        usb_hub_info_t *hub = (usb_hub_info_t *) arg;
    152155
     
    171174leave:
    172175        /* FIXME: proper interval. */
    173         async_usleep(1000 * 250);
     176        async_usleep(1000 * 1000 * 10);
    174177
    175178        return true;
     
    213216        // get hub descriptor
    214217        usb_log_debug("creating serialized descriptor\n");
    215         uint8_t serialized_descriptor[USB_HUB_MAX_DESCRIPTOR_SIZE];
     218        void * serialized_descriptor = malloc(USB_HUB_MAX_DESCRIPTOR_SIZE);
    216219        usb_hub_descriptor_t * descriptor;
    217220        int opResult;
     
    231234        }
    232235        usb_log_debug2("deserializing descriptor\n");
    233         descriptor = usb_create_deserialized_hub_desriptor(
    234             serialized_descriptor);
     236        descriptor = usb_deserialize_hub_desriptor(serialized_descriptor);
    235237        if (descriptor == NULL) {
    236238                usb_log_warning("could not deserialize descriptor \n");
    237                 return ENOMEM;
     239                return opResult;
    238240        }
    239241        usb_log_debug("setting port count to %d\n", descriptor->ports_count);
    240242        hub_info->port_count = descriptor->ports_count;
    241243        /// \TODO this is not semantically correct
    242         bool is_power_switched =
    243             ((descriptor->hub_characteristics & 1) ==0);
    244         bool has_individual_port_powering =
    245             ((descriptor->hub_characteristics & 1) !=0);
    246244        hub_info->ports = malloc(
    247245            sizeof (usb_hub_port_t) * (hub_info->port_count + 1));
    248         if(!hub_info->ports){
    249                 return ENOMEM;
    250         }
    251246        size_t port;
    252         for (port = 0; port < hub_info->port_count + 1; ++port) {
     247        for (port = 0; port < hub_info->port_count + 1; port++) {
    253248                usb_hub_port_init(&hub_info->ports[port]);
    254249        }
    255         if(is_power_switched){
    256                 usb_log_debug("is_power_switched\n");
    257                
    258                 if(!has_individual_port_powering){
    259                         usb_log_debug("!has_individual_port_powering\n");
    260                         opResult = usb_hub_set_feature(hub_info->control_pipe,
    261                             USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
    262                         if (opResult != EOK) {
    263                                 usb_log_error("cannot power hub: %s\n",
    264                                     str_error(opResult));
    265                         }
    266                 }
    267 
    268                 for (port = 1; port <= hub_info->port_count; ++port) {
    269                         usb_log_debug("Powering port %zu.\n",port);
    270                         opResult = usb_hub_set_port_feature(hub_info->control_pipe,
    271                             port, USB_HUB_FEATURE_PORT_POWER);
    272                         if (opResult != EOK) {
    273                                 usb_log_error("cannot power on port %zu: %s.\n",
    274                                     port, str_error(opResult));
    275                         }
    276                 }
    277                
    278         }else{
    279                 usb_log_debug("!is_power_switched, not going to be powered\n");
    280         }
    281250        usb_log_debug2("freeing data\n");
     251        free(serialized_descriptor);
     252        free(descriptor->devices_removable);
    282253        free(descriptor);
    283254        return EOK;
     
    341312         * auto destruction, this could work better.
    342313         */
    343         int rc = usb_hc_connection_open(&hub_info->connection);
     314        int rc = usb_pipe_start_session(hub_info->control_pipe);
    344315        if (rc != EOK) {
    345                 //usb_pipe_end_session(hub_info->control_pipe);
     316                usb_log_error("Failed to start session on control pipe: %s.\n",
     317                    str_error(rc));
     318                return rc;
     319        }
     320        rc = usb_hc_connection_open(&hub_info->connection);
     321        if (rc != EOK) {
     322                usb_pipe_end_session(hub_info->control_pipe);
    346323                usb_log_error("Failed to open connection to HC: %s.\n",
    347324                    str_error(rc));
     
    359336        }
    360337
    361         usb_log_info("Controlling hub `%s' (%zu ports).\n",
     338        usb_log_info("Controlling hub `%s' (%d ports).\n",
    362339            hub_info->usb_device->ddf_dev->name, hub_info->port_count);
    363340        return EOK;
     
    412389    usb_hub_status_t status) {
    413390        int opResult;
    414         if (!usb_hub_is_status(status,USB_HUB_FEATURE_HUB_LOCAL_POWER)) {
     391        if (usb_hub_is_status(status,USB_HUB_FEATURE_HUB_LOCAL_POWER)) {
    415392                //restart power on hub
    416393                opResult = usb_hub_set_feature(hub_info->control_pipe,
     
    422399        } else {//power reestablished on hub- restart ports
    423400                size_t port;
    424                 for (port = 1; port <= hub_info->port_count; ++port) {
     401                for (port = 0; port < hub_info->port_count; ++port) {
    425402                        opResult = usb_hub_set_port_feature(
    426403                            hub_info->control_pipe,
    427404                            port, USB_HUB_FEATURE_PORT_POWER);
    428405                        if (opResult != EOK) {
    429                                 usb_log_error("Cannot power on port %zu: %s.\n",
    430                                     port, str_error(opResult));
     406                                usb_log_error("cannot power on port %d;  %d\n",
     407                                    port, opResult);
    431408                        }
    432                 }
    433                 opResult = usb_hub_clear_feature(hub_info->control_pipe,
    434                     USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
    435                 if (opResult != EOK) {
    436                         usb_log_error("cannnot clear hub power change flag: "
    437                             "%d\n",
    438                             opResult);
    439409                }
    440410        }
Note: See TracChangeset for help on using the changeset viewer.