Changeset ab545980 in mainline for uspace/drv/bus/usb/usbhub/usbhub.c


Ignore:
Timestamp:
2011-09-27T11:37:44Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
747a1e71
Parents:
c94f643 (diff), a1cb170 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge from usb branch.

usbhub driver rewrite.

There are still some TODOs to fix but the
codebase should be smaller and cleaner.

File:
1 edited

Legend:

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

    rc94f643 rab545980  
    11/*
    22 * Copyright (c) 2010 Matus Dekanek
     3 * Copyright (c) 2011 Jan Vesely
    34 * All rights reserved.
    45 *
     
    3839#include <str_error.h>
    3940#include <inttypes.h>
    40 
    41 #include <usb_iface.h>
     41#include <stdio.h>
     42
     43#include <usb/usb.h>
     44#include <usb/debug.h>
     45#include <usb/dev/pipes.h>
     46#include <usb/classes/classes.h>
    4247#include <usb/ddfiface.h>
    4348#include <usb/descriptor.h>
     
    4651#include <usb/classes/hub.h>
    4752#include <usb/dev/poll.h>
    48 #include <stdio.h>
     53#include <usb_iface.h>
    4954
    5055#include "usbhub.h"
    51 #include "usbhub_private.h"
    52 #include "port_status.h"
    53 #include <usb/usb.h>
    54 #include <usb/dev/pipes.h>
    55 #include <usb/classes/classes.h>
    56 
    57 
     56#include "status.h"
     57
     58#define HUB_FNC_NAME "hub"
     59
     60/** Standard get hub global status request */
     61static const usb_device_request_setup_packet_t get_hub_status_request = {
     62        .request_type = USB_HUB_REQ_TYPE_GET_HUB_STATUS,
     63        .request = USB_HUB_REQUEST_GET_STATUS,
     64        .index = 0,
     65        .value = 0,
     66        .length = sizeof(usb_hub_status_t),
     67};
     68
     69static int usb_set_first_configuration(usb_device_t *usb_device);
    5870static usb_hub_info_t * usb_hub_info_create(usb_device_t *usb_dev);
    59 
    6071static int usb_hub_process_hub_specific_info(usb_hub_info_t *hub_info);
    61 
    62 static int usb_hub_set_configuration(usb_hub_info_t *hub_info);
    63 
    64 static int usb_hub_start_hub_fibril(usb_hub_info_t *hub_info);
    65 
    66 static int usb_process_hub_over_current(usb_hub_info_t *hub_info,
     72static void usb_hub_over_current(const usb_hub_info_t *hub_info,
    6773    usb_hub_status_t status);
    68 
    69 static int usb_process_hub_local_power_change(usb_hub_info_t *hub_info,
    70     usb_hub_status_t status);
    71 
    72 static void usb_hub_process_global_interrupt(usb_hub_info_t *hub_info);
    73 
     74static void usb_hub_global_interrupt(const usb_hub_info_t *hub_info);
    7475static void usb_hub_polling_terminated_callback(usb_device_t *device,
    7576    bool was_error, void *data);
    7677
    77 
    78 //*********************************************
    79 //
    80 //  hub driver code, initialization
    81 //
    82 //*********************************************
    83 
    8478/**
    8579 * Initialize hub device driver fibril
    8680 *
    87  * Creates hub representation and fibril that periodically checks hub`s status.
     81 * Creates hub representation and fibril that periodically checks hub's status.
    8882 * Hub representation is passed to the fibril.
    8983 * @param usb_dev generic usb device information
    9084 * @return error code
    9185 */
    92 int usb_hub_add_device(usb_device_t *usb_dev) {
    93         if (!usb_dev) return EINVAL;
     86int usb_hub_add_device(usb_device_t *usb_dev)
     87{
     88        assert(usb_dev);
     89        /* Create driver soft-state structure */
    9490        usb_hub_info_t *hub_info = usb_hub_info_create(usb_dev);
    95         //create hc connection
     91        if (hub_info == NULL) {
     92                usb_log_error("Failed to create hun driver structure.\n");
     93                return ENOMEM;
     94        }
     95
     96        /* Create hc connection */
    9697        usb_log_debug("Initializing USB wire abstraction.\n");
    9798        int opResult = usb_hc_connection_initialize_from_device(
    98             &hub_info->connection,
    99             hub_info->usb_device->ddf_dev);
    100         if (opResult != EOK) {
    101                 usb_log_error("Could not initialize connection to device, "
    102                     " %s\n",
    103                     str_error(opResult));
    104                 free(hub_info);
    105                 return opResult;
    106         }
    107 
    108         //set hub configuration
    109         opResult = usb_hub_set_configuration(hub_info);
    110         if (opResult != EOK) {
    111                 usb_log_error("Could not set hub configuration, %s\n",
    112                     str_error(opResult));
    113                 free(hub_info);
    114                 return opResult;
    115         }
     99            &hub_info->connection, hub_info->usb_device->ddf_dev);
     100        if (opResult != EOK) {
     101                usb_log_error("Could not initialize connection to device: %s\n",
     102                    str_error(opResult));
     103                free(hub_info);
     104                return opResult;
     105        }
     106
     107        /* Set hub's first configuration. (There should be only one) */
     108        opResult = usb_set_first_configuration(usb_dev);
     109        if (opResult != EOK) {
     110                usb_log_error("Could not set hub configuration: %s\n",
     111                    str_error(opResult));
     112                free(hub_info);
     113                return opResult;
     114        }
     115
    116116        //get port count and create attached_devs
    117117        opResult = usb_hub_process_hub_specific_info(hub_info);
     
    123123        }
    124124
    125         usb_log_debug("Creating 'hub' function in DDF.\n");
     125        usb_log_debug("Creating DDF function '" HUB_FNC_NAME "'.\n");
    126126        ddf_fun_t *hub_fun = ddf_fun_create(hub_info->usb_device->ddf_dev,
    127             fun_exposed, "hub");
    128         assert(hub_fun != NULL);
    129         hub_fun->ops = NULL;
     127            fun_exposed, HUB_FNC_NAME);
     128        if (hub_fun == NULL) {
     129                usb_log_error("Failed to create hub function.\n");
     130                free(hub_info);
     131                return ENOMEM;
     132        }
    130133
    131134        opResult = ddf_fun_bind(hub_fun);
    132         assert(opResult == EOK);
    133 
    134         opResult = usb_hub_start_hub_fibril(hub_info);
    135         if (opResult != EOK)
    136                 free(hub_info);
    137         return opResult;
    138 }
    139 
     135        if (opResult != EOK) {
     136                usb_log_error("Failed to bind hub function: %s.\n",
     137                   str_error(opResult));
     138                free(hub_info);
     139                ddf_fun_destroy(hub_fun);
     140                return opResult;
     141        }
     142
     143        opResult = usb_device_auto_poll(hub_info->usb_device, 0,
     144            hub_port_changes_callback, ((hub_info->port_count + 1) / 8) + 1,
     145            usb_hub_polling_terminated_callback, hub_info);
     146        if (opResult != EOK) {
     147                ddf_fun_destroy(hub_fun);
     148                free(hub_info);
     149                usb_log_error("Failed to create polling fibril: %s.\n",
     150                    str_error(opResult));
     151                return opResult;
     152        }
     153        usb_log_info("Controlling hub '%s' (%zu ports).\n",
     154            hub_info->usb_device->ddf_dev->name, hub_info->port_count);
     155
     156        return EOK;
     157}
     158/*----------------------------------------------------------------------------*/
    140159/** Callback for polling hub for changes.
    141160 *
     
    147166 */
    148167bool hub_port_changes_callback(usb_device_t *dev,
    149     uint8_t *change_bitmap, size_t change_bitmap_size, void *arg) {
     168    uint8_t *change_bitmap, size_t change_bitmap_size, void *arg)
     169{
    150170        usb_log_debug("hub_port_changes_callback\n");
    151         usb_hub_info_t *hub = (usb_hub_info_t *) arg;
    152 
    153         /* FIXME: check that we received enough bytes. */
     171        usb_hub_info_t *hub = arg;
     172        assert(hub);
     173
     174        /* It is an error condition if we didn't receive enough data */
    154175        if (change_bitmap_size == 0) {
    155                 goto leave;
    156         }
    157 
    158         bool change;
    159         change = ((uint8_t*) change_bitmap)[0] & 1;
     176                return false;
     177        }
     178
     179        /* Lowest bit indicates global change */
     180        const bool change = change_bitmap[0] & 1;
    160181        if (change) {
    161                 usb_hub_process_global_interrupt(hub);
    162         }
    163 
    164         size_t port;
    165         for (port = 1; port < hub->port_count + 1; port++) {
    166                 bool change = (change_bitmap[port / 8] >> (port % 8)) % 2;
     182                usb_hub_global_interrupt(hub);
     183        }
     184
     185        /* N + 1 bit indicates change on port N */
     186        size_t port = 1;
     187        for (; port < hub->port_count + 1; port++) {
     188                const bool change = (change_bitmap[port / 8] >> (port % 8)) & 1;
    167189                if (change) {
    168                         usb_hub_process_port_interrupt(hub, port);
     190                        usb_hub_port_process_interrupt(&hub->ports[port], hub);
    169191                }
    170192        }
    171 leave:
    172         /* FIXME: proper interval. */
    173         async_usleep(1000 * 250);
    174 
    175193        return true;
    176194}
    177 
    178 
    179 //*********************************************
    180 //
    181 //  support functions
    182 //
    183 //*********************************************
    184 
     195/*----------------------------------------------------------------------------*/
    185196/**
    186197 * create usb_hub_info_t structure
     
    190201 * @return basic usb_hub_info_t structure
    191202 */
    192 static usb_hub_info_t * usb_hub_info_create(usb_device_t *usb_dev) {
    193         usb_hub_info_t * result = malloc(sizeof (usb_hub_info_t));
    194         if (!result) return NULL;
    195         result->usb_device = usb_dev;
    196         result->status_change_pipe = usb_dev->pipes[0].pipe;
    197         result->control_pipe = &usb_dev->ctrl_pipe;
    198         result->is_default_address_used = false;
    199 
    200         result->ports = NULL;
    201         result->port_count = (size_t) - 1;
    202         fibril_mutex_initialize(&result->port_mutex);
    203 
    204         fibril_mutex_initialize(&result->pending_ops_mutex);
    205         fibril_condvar_initialize(&result->pending_ops_cv);
    206         result->pending_ops_count = 0;
    207         return result;
    208 }
    209 
     203static usb_hub_info_t * usb_hub_info_create(usb_device_t *usb_dev)
     204{
     205        assert(usb_dev);
     206        usb_hub_info_t *info = malloc(sizeof(usb_hub_info_t));
     207        if (!info)
     208            return NULL;
     209
     210        info->usb_device = usb_dev;
     211
     212        info->ports = NULL;
     213        info->port_count = -1;
     214        fibril_mutex_initialize(&info->pending_ops_mutex);
     215        fibril_condvar_initialize(&info->pending_ops_cv);
     216        info->pending_ops_count = 0;
     217
     218        return info;
     219}
     220/*----------------------------------------------------------------------------*/
    210221/**
    211222 * Load hub-specific information into hub_info structure and process if needed
    212223 *
    213  * Particularly read port count and initialize structure holding port
    214  * information. If there are non-removable devices, start initializing them.
     224 * Read port count and initialize structures holding per port information.
     225 * If there are any non-removable devices, start initializing them.
    215226 * This function is hub-specific and should be run only after the hub is
    216  * configured using usb_hub_set_configuration function.
     227 * configured using usb_set_first_configuration function.
    217228 * @param hub_info hub representation
    218229 * @return error code
    219230 */
    220 int usb_hub_process_hub_specific_info(usb_hub_info_t *hub_info)
    221 {
    222         // get hub descriptor
     231static int usb_hub_process_hub_specific_info(usb_hub_info_t *hub_info)
     232{
     233        assert(hub_info);
     234
     235        /* Get hub descriptor. */
    223236        usb_log_debug("Retrieving descriptor\n");
    224         uint8_t serialized_descriptor[USB_HUB_MAX_DESCRIPTOR_SIZE];
    225         int opResult;
    226 
     237        usb_pipe_t *control_pipe = &hub_info->usb_device->ctrl_pipe;
     238
     239        usb_hub_descriptor_header_t descriptor;
    227240        size_t received_size;
    228         opResult = usb_request_get_descriptor(hub_info->control_pipe,
     241        int opResult = usb_request_get_descriptor(control_pipe,
    229242            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_DEVICE,
    230             USB_DESCTYPE_HUB, 0, 0, serialized_descriptor,
    231             USB_HUB_MAX_DESCRIPTOR_SIZE, &received_size);
    232 
     243            USB_DESCTYPE_HUB, 0, 0, &descriptor,
     244            sizeof(usb_hub_descriptor_t), &received_size);
    233245        if (opResult != EOK) {
    234246                usb_log_error("Failed to receive hub descriptor: %s.\n",
     
    236248                return opResult;
    237249        }
    238         usb_log_debug2("Parsing descriptor\n");
    239         usb_hub_descriptor_t descriptor;
    240         opResult = usb_deserialize_hub_desriptor(
    241                 serialized_descriptor, received_size, &descriptor);
    242         if (opResult != EOK) {
    243                 usb_log_error("Could not parse descriptor: %s\n",
    244                     str_error(opResult));
    245                 return opResult;
    246         }
    247         usb_log_debug("Setting port count to %d.\n", descriptor.ports_count);
    248         hub_info->port_count = descriptor.ports_count;
    249 
     250
     251        usb_log_debug("Setting port count to %d.\n", descriptor.port_count);
     252        hub_info->port_count = descriptor.port_count;
     253
     254        // TODO: +1 hack is no longer necessary
    250255        hub_info->ports =
    251256            malloc(sizeof(usb_hub_port_t) * (hub_info->port_count + 1));
     
    256261        size_t port;
    257262        for (port = 0; port < hub_info->port_count + 1; ++port) {
    258                 usb_hub_port_init(&hub_info->ports[port]);
     263                usb_hub_port_init(&hub_info->ports[port], port, control_pipe);
    259264        }
    260265
    261266        const bool is_power_switched =
    262             !(descriptor.hub_characteristics & HUB_CHAR_NO_POWER_SWITCH_FLAG);
     267            !(descriptor.characteristics & HUB_CHAR_NO_POWER_SWITCH_FLAG);
    263268        if (is_power_switched) {
    264269                usb_log_debug("Hub power switched\n");
    265                 const bool per_port_power = descriptor.hub_characteristics
     270                const bool per_port_power = descriptor.characteristics
    266271                    & HUB_CHAR_POWER_PER_PORT_FLAG;
    267272
    268273                for (port = 1; port <= hub_info->port_count; ++port) {
    269274                        usb_log_debug("Powering port %zu.\n", port);
    270                         opResult = usb_hub_set_port_feature(
    271                             hub_info->control_pipe,
    272                             port, USB_HUB_FEATURE_PORT_POWER);
     275                        opResult = usb_hub_port_set_feature(
     276                            &hub_info->ports[port], USB_HUB_FEATURE_PORT_POWER);
    273277                        if (opResult != EOK) {
    274278                                usb_log_error("Cannot power on port %zu: %s.\n",
     
    283287                        }
    284288                }
    285 
    286289        } else {
    287                 usb_log_debug("Power not switched, not going to be powered\n");
     290                usb_log_debug("Power not switched, ports always powered\n");
    288291        }
    289292        return EOK;
    290293}
    291 
    292 /**
    293  * Set configuration of hub
     294/*----------------------------------------------------------------------------*/
     295/**
     296 * Set configuration of and USB device
    294297 *
    295298 * Check whether there is at least one configuration and sets the first one.
    296299 * This function should be run prior to running any hub-specific action.
    297  * @param hub_info hub representation
     300 * @param usb_device usb device representation
    298301 * @return error code
    299302 */
    300 static int usb_hub_set_configuration(usb_hub_info_t *hub_info) {
    301         //device descriptor
    302         usb_standard_device_descriptor_t *std_descriptor
    303             = &hub_info->usb_device->descriptors.device;
    304         usb_log_debug("Hub has %d configurations\n",
    305             std_descriptor->configuration_count);
    306         if (std_descriptor->configuration_count < 1) {
     303static int usb_set_first_configuration(usb_device_t *usb_device)
     304{
     305        assert(usb_device);
     306        /* Get number of possible configurations from device descriptor */
     307        const size_t configuration_count =
     308            usb_device->descriptors.device.configuration_count;
     309        usb_log_debug("Hub has %d configurations.\n", configuration_count);
     310
     311        if (configuration_count < 1) {
    307312                usb_log_error("There are no configurations available\n");
    308313                return EINVAL;
    309314        }
    310315
     316        // TODO: Make sure that there is enough data and the cast is correct
    311317        usb_standard_configuration_descriptor_t *config_descriptor
    312318            = (usb_standard_configuration_descriptor_t *)
    313             hub_info->usb_device->descriptors.configuration;
    314 
    315         /* Set configuration. */
    316         int opResult = usb_request_set_configuration(
    317             &hub_info->usb_device->ctrl_pipe,
    318             config_descriptor->configuration_number);
    319 
     319            usb_device->descriptors.configuration;
     320
     321        /* Set configuration. Use the configuration that was in
     322         * usb_device->descriptors.configuration i.e. The first one. */
     323        const int opResult = usb_request_set_configuration(
     324            &usb_device->ctrl_pipe, config_descriptor->configuration_number);
    320325        if (opResult != EOK) {
    321326                usb_log_error("Failed to set hub configuration: %s.\n",
    322327                    str_error(opResult));
    323                 return opResult;
    324         }
    325         usb_log_debug("\tUsed configuration %d\n",
    326             config_descriptor->configuration_number);
    327 
    328         return EOK;
    329 }
    330 
    331 /**
    332  * create and start fibril with hub control loop
    333  *
    334  * Before the fibril is started, the control pipe and host controller
    335  * connection of the hub is open.
    336  *
    337  * @param hub_info hub representing structure
    338  * @return error code
    339  */
    340 static int usb_hub_start_hub_fibril(usb_hub_info_t *hub_info) {
    341         int rc;
    342 
    343         rc = usb_device_auto_poll(hub_info->usb_device, 0,
    344             hub_port_changes_callback, ((hub_info->port_count + 1) / 8) + 1,
    345             usb_hub_polling_terminated_callback, hub_info);
    346         if (rc != EOK) {
    347                 usb_log_error("Failed to create polling fibril: %s.\n",
    348                     str_error(rc));
    349                 free(hub_info);
    350                 return rc;
    351         }
    352 
    353         usb_log_info("Controlling hub `%s' (%zu ports).\n",
    354             hub_info->usb_device->ddf_dev->name, hub_info->port_count);
    355         return EOK;
    356 }
    357 
    358 //*********************************************
    359 //
    360 //  change handling functions
    361 //
    362 //*********************************************
    363 
    364 /**
    365  * process hub over current change
     328        } else {
     329                usb_log_debug("\tUsed configuration %d\n",
     330                    config_descriptor->configuration_number);
     331        }
     332        return opResult;
     333}
     334/*----------------------------------------------------------------------------*/
     335/**
     336 * Process hub over current change
    366337 *
    367338 * This means either to power off the hub or power it on.
     
    370341 * @return error code
    371342 */
    372 static int usb_process_hub_over_current(usb_hub_info_t *hub_info,
    373     usb_hub_status_t status) {
    374         int opResult;
    375         if (usb_hub_is_status(status, USB_HUB_FEATURE_HUB_OVER_CURRENT)) {
    376                 //poweroff all ports
    377                 unsigned int port;
     343static void usb_hub_over_current(const usb_hub_info_t *hub_info,
     344    usb_hub_status_t status)
     345{
     346        if (status & USB_HUB_STATUS_OVER_CURRENT) {
     347                /* Hub should remove power from all ports if it detects OC */
     348                usb_log_warning("Detected hub over-current condition, "
     349                    "all ports should be powered off.");
     350        } else {
     351                /* Over-current condition is gone, it is safe to turn the
     352                 * ports on. */
     353                size_t port;
    378354                for (port = 1; port <= hub_info->port_count; ++port) {
    379                         opResult = usb_hub_clear_port_feature(
    380                             hub_info->control_pipe, port,
    381                             USB_HUB_FEATURE_PORT_POWER);
     355                        const int opResult = usb_hub_port_set_feature(
     356                            &hub_info->ports[port], USB_HUB_FEATURE_PORT_POWER);
    382357                        if (opResult != EOK) {
    383358                                usb_log_warning(
    384                                     "Cannot power off port %d;  %s\n",
     359                                    "HUB OVER-CURRENT GONE: Cannot power on "
     360                                    "port %d;  %s\n",
    385361                                    port, str_error(opResult));
    386362                        }
    387363                }
    388         } else {
    389                 //power all ports
    390                 unsigned int port;
    391                 for (port = 1; port <= hub_info->port_count; ++port) {
    392                         opResult = usb_hub_set_port_feature(
    393                             hub_info->control_pipe, port,
    394                             USB_HUB_FEATURE_PORT_POWER);
    395                         if (opResult != EOK) {
    396                                 usb_log_warning(
    397                                     "Cannot power off port %d;  %s\n",
    398                                     port, str_error(opResult));
    399                         }
    400                 }
    401         }
    402         return opResult;
    403 }
    404 
    405 /**
    406  * process hub local power change
    407  *
    408  * This change is ignored.
     364        }
     365        const int opResult = usb_request_clear_feature(
     366            &hub_info->usb_device->ctrl_pipe, USB_REQUEST_TYPE_CLASS,
     367            USB_REQUEST_RECIPIENT_DEVICE,
     368            USB_HUB_FEATURE_C_HUB_LOCAL_POWER, 0);
     369        if (opResult != EOK) {
     370                usb_log_error(
     371                    "Failed to clear hub over-current change flag: %s.\n",
     372                    str_error(opResult));
     373        }
     374}
     375/*----------------------------------------------------------------------------*/
     376/**
     377 * Process hub interrupts.
     378 *
     379 * The change can be either in the over-current condition or local-power change.
    409380 * @param hub_info hub instance
    410  * @param status hub status bitmask
    411  * @return error code
    412  */
    413 static int usb_process_hub_local_power_change(usb_hub_info_t *hub_info,
    414     usb_hub_status_t status) {
    415         int opResult = EOK;
    416         opResult = usb_hub_clear_feature(hub_info->control_pipe,
    417             USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
    418         if (opResult != EOK) {
    419                 usb_log_error("Cannnot clear hub power change flag: "
    420                     "%s\n",
    421                     str_error(opResult));
    422         }
    423         return opResult;
    424 }
    425 
    426 /**
    427  * process hub interrupts
    428  *
    429  * The change can be either in the over-current condition or
    430  * local-power change.
    431  * @param hub_info hub instance
    432  */
    433 static void usb_hub_process_global_interrupt(usb_hub_info_t *hub_info) {
     381 */
     382static void usb_hub_global_interrupt(const usb_hub_info_t *hub_info)
     383{
     384        assert(hub_info);
     385        assert(hub_info->usb_device);
    434386        usb_log_debug("Global interrupt on a hub\n");
    435         usb_pipe_t *pipe = hub_info->control_pipe;
    436         int opResult;
    437 
    438         usb_port_status_t status;
     387        usb_pipe_t *control_pipe = &hub_info->usb_device->ctrl_pipe;
     388
     389        usb_hub_status_t status;
    439390        size_t rcvd_size;
    440         usb_device_request_setup_packet_t request;
    441         //int opResult;
    442         usb_hub_set_hub_status_request(&request);
    443         //endpoint 0
    444 
    445         opResult = usb_pipe_control_read(
    446             pipe,
    447             &request, sizeof (usb_device_request_setup_packet_t),
    448             &status, 4, &rcvd_size
    449             );
     391        /* NOTE: We can't use standard USB GET_STATUS request, because
     392         * hubs reply is 4byte instead of 2 */
     393        const int opResult = usb_pipe_control_read(control_pipe,
     394            &get_hub_status_request, sizeof(get_hub_status_request),
     395            &status, sizeof(usb_hub_status_t), &rcvd_size);
    450396        if (opResult != EOK) {
    451397                usb_log_error("Could not get hub status: %s\n",
     
    453399                return;
    454400        }
    455         if (rcvd_size != sizeof (usb_port_status_t)) {
     401        if (rcvd_size != sizeof(usb_hub_status_t)) {
    456402                usb_log_error("Received status has incorrect size\n");
    457403                return;
    458404        }
    459         //port reset
    460         if (
    461             usb_hub_is_status(status, 16 + USB_HUB_FEATURE_C_HUB_OVER_CURRENT)) {
    462                 usb_process_hub_over_current(hub_info, status);
    463         }
    464         if (
    465             usb_hub_is_status(status, 16 + USB_HUB_FEATURE_C_HUB_LOCAL_POWER)) {
    466                 usb_process_hub_local_power_change(hub_info, status);
    467         }
    468 }
    469 
     405
     406        /* Handle status changes */
     407        if (status & USB_HUB_STATUS_C_OVER_CURRENT) {
     408                usb_hub_over_current(hub_info, status);
     409        }
     410
     411        if (status & USB_HUB_STATUS_C_LOCAL_POWER) {
     412                /* NOTE: Handling this is more complicated.
     413                 * If the transition is from bus power to local power, all
     414                 * is good and we may signal the parent hub that we don't
     415                 * need the power.
     416                 * If the transition is from local power to bus power
     417                 * the hub should turn off all the ports and devices need
     418                 * to be reinitialized taking into account the limited power
     419                 * that is now available.
     420                 * There is no support for power distribution in HelenOS,
     421                 * (or other OSes/hub devices that I've seen) so this is not
     422                 * implemented.
     423                 * Just ACK the change.
     424                 */
     425                const int opResult = usb_request_clear_feature(
     426                    control_pipe, USB_REQUEST_TYPE_CLASS,
     427                    USB_REQUEST_RECIPIENT_DEVICE,
     428                    USB_HUB_FEATURE_C_HUB_LOCAL_POWER, 0);
     429                if (opResult != EOK) {
     430                        usb_log_error(
     431                            "Failed to clear hub power change flag: %s.\n",
     432                            str_error(opResult));
     433                }
     434        }
     435}
     436/*----------------------------------------------------------------------------*/
    470437/**
    471438 * callback called from hub polling fibril when the fibril terminates
     
    477444 */
    478445static void usb_hub_polling_terminated_callback(usb_device_t *device,
    479     bool was_error, void *data) {
    480         usb_hub_info_t * hub = data;
     446    bool was_error, void *data)
     447{
     448        usb_hub_info_t *hub = data;
    481449        assert(hub);
    482450
     
    492460         */
    493461        if (hub->pending_ops_count > 0) {
    494                 fibril_mutex_lock(&hub->port_mutex);
    495462                size_t port;
    496463                for (port = 0; port < hub->port_count; port++) {
    497                         usb_hub_port_t *the_port = hub->ports + port;
    498                         fibril_mutex_lock(&the_port->reset_mutex);
    499                         the_port->reset_completed = true;
    500                         the_port->reset_okay = false;
    501                         fibril_condvar_broadcast(&the_port->reset_cv);
    502                         fibril_mutex_unlock(&the_port->reset_mutex);
     464                        usb_hub_port_reset_fail(&hub->ports[port]);
    503465                }
    504                 fibril_mutex_unlock(&hub->port_mutex);
    505466        }
    506467        /* And now wait for them. */
     
    516477        free(hub);
    517478}
    518 
    519 
    520 
    521 
    522479/**
    523480 * @}
Note: See TracChangeset for help on using the changeset viewer.