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


Ignore:
Timestamp:
2012-02-18T16:47:38Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
4449c6c
Parents:
bd5f3b7 (diff), f943dd3 (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 mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/bus/usb/usbhub/usbhub.c

    rbd5f3b7 r00aece0  
    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 
    58 static usb_hub_info_t * usb_hub_info_create(usb_device_t *usb_dev);
    59 
    60 static 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,
     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);
     70static int usb_hub_process_hub_specific_info(usb_hub_dev_t *hub_dev);
     71static void usb_hub_over_current(const usb_hub_dev_t *hub_dev,
    6772    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 
     73static void usb_hub_global_interrupt(const usb_hub_dev_t *hub_dev);
    7474static void usb_hub_polling_terminated_callback(usb_device_t *device,
    7575    bool was_error, void *data);
    7676
    77 
    78 //*********************************************
    79 //
    80 //  hub driver code, initialization
    81 //
    82 //*********************************************
    83 
    84 /**
    85  * Initialize hub device driver fibril
    86  *
    87  * Creates hub representation and fibril that periodically checks hub`s status.
     77/**
     78 * Initialize hub device driver structure.
     79 *
     80 * Creates hub representation and fibril that periodically checks hub's status.
    8881 * Hub representation is passed to the fibril.
    8982 * @param usb_dev generic usb device information
    9083 * @return error code
    9184 */
    92 int usb_hub_add_device(usb_device_t *usb_dev) {
    93         if (!usb_dev) return EINVAL;
    94         usb_hub_info_t *hub_info = usb_hub_info_create(usb_dev);
    95         //create hc connection
    96         usb_log_debug("Initializing USB wire abstraction.\n");
    97         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);
     85int usb_hub_device_add(usb_device_t *usb_dev)
     86{
     87        assert(usb_dev);
     88        /* Create driver soft-state structure */
     89        usb_hub_dev_t *hub_dev =
     90            usb_device_data_alloc(usb_dev, sizeof(usb_hub_dev_t));
     91        if (hub_dev == NULL) {
     92                usb_log_error("Failed to create hub driver structure.\n");
     93                return ENOMEM;
     94        }
     95        hub_dev->usb_device = usb_dev;
     96        hub_dev->pending_ops_count = 0;
     97        hub_dev->running = false;
     98        fibril_mutex_initialize(&hub_dev->pending_ops_mutex);
     99        fibril_condvar_initialize(&hub_dev->pending_ops_cv);
     100
     101
     102        int opResult = usb_pipe_start_long_transfer(&usb_dev->ctrl_pipe);
     103        if (opResult != EOK) {
     104                usb_log_error("Failed to start long ctrl pipe transfer: %s\n",
     105                    str_error(opResult));
    105106                return opResult;
    106107        }
    107108
    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);
     109        /* Set hub's first configuration. (There should be only one) */
     110        opResult = usb_set_first_configuration(usb_dev);
     111        if (opResult != EOK) {
     112                usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
     113                usb_log_error("Could not set hub configuration: %s\n",
     114                    str_error(opResult));
    114115                return opResult;
    115116        }
    116         //get port count and create attached_devs
    117         opResult = usb_hub_process_hub_specific_info(hub_info);
    118         if (opResult != EOK) {
     117
     118        /* Get port count and create attached_devices. */
     119        opResult = usb_hub_process_hub_specific_info(hub_dev);
     120        if (opResult != EOK) {
     121                usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
    119122                usb_log_error("Could process hub specific info, %s\n",
    120123                    str_error(opResult));
    121                 free(hub_info);
    122124                return opResult;
    123125        }
    124126
    125         usb_log_debug("Creating 'hub' function in DDF.\n");
    126         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;
    130 
    131         opResult = ddf_fun_bind(hub_fun);
    132         assert(opResult == EOK);
    133         opResult = ddf_fun_add_to_category(hub_fun, "hub");
    134         assert(opResult == EOK);
    135 
    136         opResult = usb_hub_start_hub_fibril(hub_info);
    137         if (opResult != EOK)
    138                 free(hub_info);
    139         return opResult;
    140 }
    141 
     127        /* Create hub control function. */
     128        usb_log_debug("Creating DDF function '" HUB_FNC_NAME "'.\n");
     129        hub_dev->hub_fun = ddf_fun_create(hub_dev->usb_device->ddf_dev,
     130            fun_exposed, HUB_FNC_NAME);
     131        if (hub_dev->hub_fun == NULL) {
     132                usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
     133                usb_log_error("Failed to create hub function.\n");
     134                return ENOMEM;
     135        }
     136
     137        /* Bind hub control function. */
     138        opResult = ddf_fun_bind(hub_dev->hub_fun);
     139        if (opResult != EOK) {
     140                usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
     141                usb_log_error("Failed to bind hub function: %s.\n",
     142                   str_error(opResult));
     143                ddf_fun_destroy(hub_dev->hub_fun);
     144                return opResult;
     145        }
     146
     147        /* Start hub operation. */
     148        opResult = usb_device_auto_poll(hub_dev->usb_device, 0,
     149            hub_port_changes_callback, ((hub_dev->port_count + 1 + 8) / 8),
     150            usb_hub_polling_terminated_callback, hub_dev);
     151        if (opResult != EOK) {
     152                usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
     153                /* Function is already bound */
     154                ddf_fun_unbind(hub_dev->hub_fun);
     155                ddf_fun_destroy(hub_dev->hub_fun);
     156                usb_log_error("Failed to create polling fibril: %s.\n",
     157                    str_error(opResult));
     158                return opResult;
     159        }
     160        hub_dev->running = true;
     161        usb_log_info("Controlling hub '%s' (%zu ports).\n",
     162            hub_dev->usb_device->ddf_dev->name, hub_dev->port_count);
     163
     164        usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
     165        return EOK;
     166}
     167/*----------------------------------------------------------------------------*/
     168/**
     169 * Turn off power to all ports.
     170 *
     171 * @param usb_dev generic usb device information
     172 * @return error code
     173 */
     174int usb_hub_device_remove(usb_device_t *usb_dev)
     175{
     176        return ENOTSUP;
     177}
     178/*----------------------------------------------------------------------------*/
     179/**
     180 * Remove all attached devices
     181 * @param usb_dev generic usb device information
     182 * @return error code
     183 */
     184int usb_hub_device_gone(usb_device_t *usb_dev)
     185{
     186        assert(usb_dev);
     187        usb_hub_dev_t *hub = usb_dev->driver_data;
     188        assert(hub);
     189        unsigned tries = 10;
     190        while (hub->running) {
     191                async_usleep(100000);
     192                if (!tries--) {
     193                        usb_log_error("Can't remove hub, still running.\n");
     194                        return EINPROGRESS;
     195                }
     196        }
     197
     198        assert(!hub->running);
     199
     200        for (size_t port = 0; port < hub->port_count; ++port) {
     201                if (hub->ports[port].attached_device.fun) {
     202                        const int ret =
     203                            usb_hub_port_fini(&hub->ports[port], hub);
     204                        if (ret != EOK)
     205                                return ret;
     206                }
     207        }
     208        free(hub->ports);
     209
     210        const int ret = ddf_fun_unbind(hub->hub_fun);
     211        if (ret != EOK) {
     212                usb_log_error("Failed to unbind '%s' function: %s.\n",
     213                   HUB_FNC_NAME, str_error(ret));
     214                return ret;
     215        }
     216        ddf_fun_destroy(hub->hub_fun);
     217
     218        usb_log_info("USB hub driver, stopped and cleaned.\n");
     219        return EOK;
     220}
     221/*----------------------------------------------------------------------------*/
    142222/** Callback for polling hub for changes.
    143223 *
    … …  
    145225 * @param change_bitmap Bitmap of changed ports.
    146226 * @param change_bitmap_size Size of the bitmap in bytes.
    147  * @param arg Custom argument, points to @c usb_hub_info_t.
     227 * @param arg Custom argument, points to @c usb_hub_dev_t.
    148228 * @return Whether to continue polling.
    149229 */
    150230bool hub_port_changes_callback(usb_device_t *dev,
    151     uint8_t *change_bitmap, size_t change_bitmap_size, void *arg) {
     231    uint8_t *change_bitmap, size_t change_bitmap_size, void *arg)
     232{
    152233        usb_log_debug("hub_port_changes_callback\n");
    153         usb_hub_info_t *hub = (usb_hub_info_t *) arg;
    154 
    155         /* FIXME: check that we received enough bytes. */
     234        usb_hub_dev_t *hub = arg;
     235        assert(hub);
     236
     237        /* It is an error condition if we didn't receive enough data */
    156238        if (change_bitmap_size == 0) {
    157                 goto leave;
    158         }
    159 
    160         bool change;
    161         change = ((uint8_t*) change_bitmap)[0] & 1;
     239                return false;
     240        }
     241
     242        /* Lowest bit indicates global change */
     243        const bool change = change_bitmap[0] & 1;
    162244        if (change) {
    163                 usb_hub_process_global_interrupt(hub);
    164         }
    165 
    166         size_t port;
    167         for (port = 1; port < hub->port_count + 1; port++) {
    168                 bool change = (change_bitmap[port / 8] >> (port % 8)) % 2;
     245                usb_hub_global_interrupt(hub);
     246        }
     247
     248        /* N + 1 bit indicates change on port N */
     249        for (size_t port = 0; port < hub->port_count + 1; port++) {
     250                const size_t bit = port + 1;
     251                const bool change = (change_bitmap[bit / 8] >> (bit % 8)) & 1;
    169252                if (change) {
    170                         usb_hub_process_port_interrupt(hub, port);
    171                 }
    172         }
    173 leave:
    174         /* FIXME: proper interval. */
    175         async_usleep(1000 * 250);
    176 
     253                        usb_hub_port_process_interrupt(&hub->ports[port], hub);
     254                }
     255        }
    177256        return true;
    178257}
    179 
    180 
    181 //*********************************************
    182 //
    183 //  support functions
    184 //
    185 //*********************************************
    186 
    187 /**
    188  * create usb_hub_info_t structure
    189  *
    190  * Does only basic copying of known information into new structure.
    191  * @param usb_dev usb device structure
    192  * @return basic usb_hub_info_t structure
    193  */
    194 static usb_hub_info_t * usb_hub_info_create(usb_device_t *usb_dev) {
    195         usb_hub_info_t * result = malloc(sizeof (usb_hub_info_t));
    196         if (!result) return NULL;
    197         result->usb_device = usb_dev;
    198         result->status_change_pipe = usb_dev->pipes[0].pipe;
    199         result->control_pipe = &usb_dev->ctrl_pipe;
    200         result->is_default_address_used = false;
    201 
    202         result->ports = NULL;
    203         result->port_count = (size_t) - 1;
    204         fibril_mutex_initialize(&result->port_mutex);
    205 
    206         fibril_mutex_initialize(&result->pending_ops_mutex);
    207         fibril_condvar_initialize(&result->pending_ops_cv);
    208         result->pending_ops_count = 0;
    209         return result;
    210 }
    211 
    212 /**
    213  * Load hub-specific information into hub_info structure and process if needed
    214  *
    215  * Particularly read port count and initialize structure holding port
    216  * information. If there are non-removable devices, start initializing them.
     258/*----------------------------------------------------------------------------*/
     259/**
     260 * Load hub-specific information into hub_dev structure and process if needed
     261 *
     262 * Read port count and initialize structures holding per port information.
     263 * If there are any non-removable devices, start initializing them.
    217264 * This function is hub-specific and should be run only after the hub is
    218  * configured using usb_hub_set_configuration function.
    219  * @param hub_info hub representation
     265 * configured using usb_set_first_configuration function.
     266 * @param hub_dev hub representation
    220267 * @return error code
    221268 */
    222 int usb_hub_process_hub_specific_info(usb_hub_info_t *hub_info)
    223 {
    224         // get hub descriptor
     269static int usb_hub_process_hub_specific_info(usb_hub_dev_t *hub_dev)
     270{
     271        assert(hub_dev);
     272
     273        /* Get hub descriptor. */
    225274        usb_log_debug("Retrieving descriptor\n");
    226         uint8_t serialized_descriptor[USB_HUB_MAX_DESCRIPTOR_SIZE];
    227         int opResult;
    228 
     275        usb_pipe_t *control_pipe = &hub_dev->usb_device->ctrl_pipe;
     276
     277        usb_hub_descriptor_header_t descriptor;
    229278        size_t received_size;
    230         opResult = usb_request_get_descriptor(hub_info->control_pipe,
     279        int opResult = usb_request_get_descriptor(control_pipe,
    231280            USB_REQUEST_TYPE_CLASS, USB_REQUEST_RECIPIENT_DEVICE,
    232             USB_DESCTYPE_HUB, 0, 0, serialized_descriptor,
    233             USB_HUB_MAX_DESCRIPTOR_SIZE, &received_size);
    234 
     281            USB_DESCTYPE_HUB, 0, 0, &descriptor,
     282            sizeof(usb_hub_descriptor_header_t), &received_size);
    235283        if (opResult != EOK) {
    236284                usb_log_error("Failed to receive hub descriptor: %s.\n",
    … …  
    238286                return opResult;
    239287        }
    240         usb_log_debug2("Parsing descriptor\n");
    241         usb_hub_descriptor_t descriptor;
    242         opResult = usb_deserialize_hub_desriptor(
    243                 serialized_descriptor, received_size, &descriptor);
    244         if (opResult != EOK) {
    245                 usb_log_error("Could not parse descriptor: %s\n",
    246                     str_error(opResult));
    247                 return opResult;
    248         }
    249         usb_log_debug("Setting port count to %d.\n", descriptor.ports_count);
    250         hub_info->port_count = descriptor.ports_count;
    251 
    252         hub_info->ports =
    253             malloc(sizeof(usb_hub_port_t) * (hub_info->port_count + 1));
    254         if (!hub_info->ports) {
     288
     289        usb_log_debug("Setting port count to %d.\n", descriptor.port_count);
     290        hub_dev->port_count = descriptor.port_count;
     291
     292        hub_dev->ports = calloc(hub_dev->port_count, sizeof(usb_hub_port_t));
     293        if (!hub_dev->ports) {
    255294                return ENOMEM;
    256295        }
    257296
    258         size_t port;
    259         for (port = 0; port < hub_info->port_count + 1; ++port) {
    260                 usb_hub_port_init(&hub_info->ports[port]);
    261         }
    262 
    263         const bool is_power_switched =
    264             !(descriptor.hub_characteristics & HUB_CHAR_NO_POWER_SWITCH_FLAG);
    265         if (is_power_switched) {
    266                 usb_log_debug("Hub power switched\n");
    267                 const bool per_port_power = descriptor.hub_characteristics
    268                     & HUB_CHAR_POWER_PER_PORT_FLAG;
    269 
    270                 for (port = 1; port <= hub_info->port_count; ++port) {
    271                         usb_log_debug("Powering port %zu.\n", port);
    272                         opResult = usb_hub_set_port_feature(
    273                             hub_info->control_pipe,
    274                             port, USB_HUB_FEATURE_PORT_POWER);
    275                         if (opResult != EOK) {
    276                                 usb_log_error("Cannot power on port %zu: %s.\n",
    277                                     port, str_error(opResult));
    278                         } else {
    279                                 if (!per_port_power) {
    280                                         usb_log_debug(
    281                                             "Ganged power switching mode, "
    282                                             "one port is enough.\n");
    283                                         break;
    284                                 }
     297        for (size_t port = 0; port < hub_dev->port_count; ++port) {
     298                usb_hub_port_init(
     299                    &hub_dev->ports[port], port + 1, control_pipe);
     300        }
     301
     302        hub_dev->power_switched =
     303            !(descriptor.characteristics & HUB_CHAR_NO_POWER_SWITCH_FLAG);
     304        hub_dev->per_port_power =
     305            descriptor.characteristics & HUB_CHAR_POWER_PER_PORT_FLAG;
     306
     307        if (!hub_dev->power_switched) {
     308                usb_log_info(
     309                   "Power switching not supported, ports always powered.\n");
     310                return EOK;
     311        }
     312
     313        usb_log_info("Hub port power switching enabled.\n");
     314
     315        for (size_t port = 0; port < hub_dev->port_count; ++port) {
     316                usb_log_debug("Powering port %zu.\n", port);
     317                const int ret = usb_hub_port_set_feature(
     318                    &hub_dev->ports[port], USB_HUB_FEATURE_PORT_POWER);
     319
     320                if (ret != EOK) {
     321                        usb_log_error("Cannot power on port %zu: %s.\n",
     322                            hub_dev->ports[port].port_number, str_error(ret));
     323                } else {
     324                        if (!hub_dev->per_port_power) {
     325                                usb_log_debug("Ganged power switching, "
     326                                    "one port is enough.\n");
     327                                break;
    285328                        }
    286329                }
    287 
    288         } else {
    289                 usb_log_debug("Power not switched, not going to be powered\n");
    290330        }
    291331        return EOK;
    292332}
    293 
    294 /**
    295  * Set configuration of hub
     333/*----------------------------------------------------------------------------*/
     334/**
     335 * Set configuration of and USB device
    296336 *
    297337 * Check whether there is at least one configuration and sets the first one.
    298338 * This function should be run prior to running any hub-specific action.
    299  * @param hub_info hub representation
     339 * @param usb_device usb device representation
    300340 * @return error code
    301341 */
    302 static int usb_hub_set_configuration(usb_hub_info_t *hub_info) {
    303         //device descriptor
    304         usb_standard_device_descriptor_t *std_descriptor
    305             = &hub_info->usb_device->descriptors.device;
    306         usb_log_debug("Hub has %d configurations\n",
    307             std_descriptor->configuration_count);
    308         if (std_descriptor->configuration_count < 1) {
     342static int usb_set_first_configuration(usb_device_t *usb_device)
     343{
     344        assert(usb_device);
     345        /* Get number of possible configurations from device descriptor */
     346        const size_t configuration_count =
     347            usb_device->descriptors.device.configuration_count;
     348        usb_log_debug("Hub has %zu configurations.\n", configuration_count);
     349
     350        if (configuration_count < 1) {
    309351                usb_log_error("There are no configurations available\n");
    310352                return EINVAL;
    311353        }
    312354
     355        if (usb_device->descriptors.configuration_size
     356            < sizeof(usb_standard_configuration_descriptor_t)) {
     357            usb_log_error("Configuration descriptor is not big enough"
     358                " to fit standard configuration descriptor.\n");
     359            return EOVERFLOW;
     360        }
     361
     362        // TODO: Make sure that the cast is correct
    313363        usb_standard_configuration_descriptor_t *config_descriptor
    314364            = (usb_standard_configuration_descriptor_t *)
    315             hub_info->usb_device->descriptors.configuration;
    316 
    317         /* Set configuration. */
    318         int opResult = usb_request_set_configuration(
    319             &hub_info->usb_device->ctrl_pipe,
    320             config_descriptor->configuration_number);
    321 
     365            usb_device->descriptors.configuration;
     366
     367        /* Set configuration. Use the configuration that was in
     368         * usb_device->descriptors.configuration i.e. The first one. */
     369        const int opResult = usb_request_set_configuration(
     370            &usb_device->ctrl_pipe, config_descriptor->configuration_number);
    322371        if (opResult != EOK) {
    323372                usb_log_error("Failed to set hub configuration: %s.\n",
    324373                    str_error(opResult));
    325                 return opResult;
    326         }
    327         usb_log_debug("\tUsed configuration %d\n",
    328             config_descriptor->configuration_number);
    329 
    330         return EOK;
    331 }
    332 
    333 /**
    334  * create and start fibril with hub control loop
    335  *
    336  * Before the fibril is started, the control pipe and host controller
    337  * connection of the hub is open.
    338  *
    339  * @param hub_info hub representing structure
    340  * @return error code
    341  */
    342 static int usb_hub_start_hub_fibril(usb_hub_info_t *hub_info) {
    343         int rc;
    344 
    345         rc = usb_device_auto_poll(hub_info->usb_device, 0,
    346             hub_port_changes_callback, ((hub_info->port_count + 1) / 8) + 1,
    347             usb_hub_polling_terminated_callback, hub_info);
    348         if (rc != EOK) {
    349                 usb_log_error("Failed to create polling fibril: %s.\n",
    350                     str_error(rc));
    351                 free(hub_info);
    352                 return rc;
    353         }
    354 
    355         usb_log_info("Controlling hub `%s' (%zu ports).\n",
    356             hub_info->usb_device->ddf_dev->name, hub_info->port_count);
    357         return EOK;
    358 }
    359 
    360 //*********************************************
    361 //
    362 //  change handling functions
    363 //
    364 //*********************************************
    365 
    366 /**
    367  * process hub over current change
     374        } else {
     375                usb_log_debug("\tUsed configuration %d\n",
     376                    config_descriptor->configuration_number);
     377        }
     378        return opResult;
     379}
     380/*----------------------------------------------------------------------------*/
     381/**
     382 * Process hub over current change
    368383 *
    369384 * This means either to power off the hub or power it on.
    370  * @param hub_info hub instance
     385 * @param hub_dev hub instance
    371386 * @param status hub status bitmask
    372387 * @return error code
    373388 */
    374 static int usb_process_hub_over_current(usb_hub_info_t *hub_info,
    375     usb_hub_status_t status) {
    376         int opResult;
    377         if (usb_hub_is_status(status, USB_HUB_FEATURE_HUB_OVER_CURRENT)) {
    378                 //poweroff all ports
    379                 unsigned int port;
    380                 for (port = 1; port <= hub_info->port_count; ++port) {
    381                         opResult = usb_hub_clear_port_feature(
    382                             hub_info->control_pipe, port,
    383                             USB_HUB_FEATURE_PORT_POWER);
    384                         if (opResult != EOK) {
    385                                 usb_log_warning(
    386                                     "Cannot power off port %d;  %s\n",
    387                                     port, str_error(opResult));
    388                         }
    389                 }
    390         } else {
    391                 //power all ports
    392                 unsigned int port;
    393                 for (port = 1; port <= hub_info->port_count; ++port) {
    394                         opResult = usb_hub_set_port_feature(
    395                             hub_info->control_pipe, port,
    396                             USB_HUB_FEATURE_PORT_POWER);
    397                         if (opResult != EOK) {
    398                                 usb_log_warning(
    399                                     "Cannot power off port %d;  %s\n",
    400                                     port, str_error(opResult));
    401                         }
    402                 }
    403         }
    404         return opResult;
    405 }
    406 
    407 /**
    408  * process hub local power change
    409  *
    410  * This change is ignored.
    411  * @param hub_info hub instance
    412  * @param status hub status bitmask
    413  * @return error code
    414  */
    415 static int usb_process_hub_local_power_change(usb_hub_info_t *hub_info,
    416     usb_hub_status_t status) {
    417         int opResult = EOK;
    418         opResult = usb_hub_clear_feature(hub_info->control_pipe,
    419             USB_HUB_FEATURE_C_HUB_LOCAL_POWER);
    420         if (opResult != EOK) {
    421                 usb_log_error("Cannnot clear hub power change flag: "
    422                     "%s\n",
    423                     str_error(opResult));
    424         }
    425         return opResult;
    426 }
    427 
    428 /**
    429  * process hub interrupts
    430  *
    431  * The change can be either in the over-current condition or
    432  * local-power change.
    433  * @param hub_info hub instance
    434  */
    435 static void usb_hub_process_global_interrupt(usb_hub_info_t *hub_info) {
     389static void usb_hub_over_current(const usb_hub_dev_t *hub_dev,
     390    usb_hub_status_t status)
     391{
     392        if (status & USB_HUB_STATUS_OVER_CURRENT) {
     393                /* Hub should remove power from all ports if it detects OC */
     394                usb_log_warning("Detected hub over-current condition, "
     395                    "all ports should be powered off.");
     396                return;
     397        }
     398
     399        /* Ports are always powered. */
     400        if (!hub_dev->power_switched)
     401                return;
     402
     403        /* Over-current condition is gone, it is safe to turn the ports on. */
     404        for (size_t port = 0; port < hub_dev->port_count; ++port) {
     405                const int ret = usb_hub_port_set_feature(
     406                    &hub_dev->ports[port], USB_HUB_FEATURE_PORT_POWER);
     407                if (ret != EOK) {
     408                        usb_log_warning("HUB OVER-CURRENT GONE: Cannot power on"
     409                            " port %zu: %s\n", hub_dev->ports[port].port_number,
     410                            str_error(ret));
     411                } else {
     412                        if (!hub_dev->per_port_power)
     413                                return;
     414                }
     415        }
     416
     417}
     418/*----------------------------------------------------------------------------*/
     419/**
     420 * Process hub interrupts.
     421 *
     422 * The change can be either in the over-current condition or local-power change.
     423 * @param hub_dev hub instance
     424 */
     425static void usb_hub_global_interrupt(const usb_hub_dev_t *hub_dev)
     426{
     427        assert(hub_dev);
     428        assert(hub_dev->usb_device);
    436429        usb_log_debug("Global interrupt on a hub\n");
    437         usb_pipe_t *pipe = hub_info->control_pipe;
    438         int opResult;
    439 
    440         usb_port_status_t status;
     430        usb_pipe_t *control_pipe = &hub_dev->usb_device->ctrl_pipe;
     431
     432        usb_hub_status_t status;
    441433        size_t rcvd_size;
    442         usb_device_request_setup_packet_t request;
    443         //int opResult;
    444         usb_hub_set_hub_status_request(&request);
    445         //endpoint 0
    446 
    447         opResult = usb_pipe_control_read(
    448             pipe,
    449             &request, sizeof (usb_device_request_setup_packet_t),
    450             &status, 4, &rcvd_size
    451             );
     434        /* NOTE: We can't use standard USB GET_STATUS request, because
     435         * hubs reply is 4byte instead of 2 */
     436        const int opResult = usb_pipe_control_read(control_pipe,
     437            &get_hub_status_request, sizeof(get_hub_status_request),
     438            &status, sizeof(usb_hub_status_t), &rcvd_size);
    452439        if (opResult != EOK) {
    453440                usb_log_error("Could not get hub status: %s\n",
    … …  
    455442                return;
    456443        }
    457         if (rcvd_size != sizeof (usb_port_status_t)) {
     444        if (rcvd_size != sizeof(usb_hub_status_t)) {
    458445                usb_log_error("Received status has incorrect size\n");
    459446                return;
    460447        }
    461         //port reset
    462         if (
    463             usb_hub_is_status(status, 16 + USB_HUB_FEATURE_C_HUB_OVER_CURRENT)) {
    464                 usb_process_hub_over_current(hub_info, status);
    465         }
    466         if (
    467             usb_hub_is_status(status, 16 + USB_HUB_FEATURE_C_HUB_LOCAL_POWER)) {
    468                 usb_process_hub_local_power_change(hub_info, status);
    469         }
    470 }
    471 
     448
     449        /* Handle status changes */
     450        if (status & USB_HUB_STATUS_C_OVER_CURRENT) {
     451                usb_hub_over_current(hub_dev, status);
     452                /* Ack change in hub OC flag */
     453                const int ret = usb_request_clear_feature(
     454                    &hub_dev->usb_device->ctrl_pipe, USB_REQUEST_TYPE_CLASS,
     455                    USB_REQUEST_RECIPIENT_DEVICE,
     456                    USB_HUB_FEATURE_C_HUB_OVER_CURRENT, 0);
     457                if (ret != EOK) {
     458                        usb_log_error("Failed to clear hub over-current "
     459                            "change flag: %s.\n", str_error(opResult));
     460                }
     461        }
     462
     463        if (status & USB_HUB_STATUS_C_LOCAL_POWER) {
     464                /* NOTE: Handling this is more complicated.
     465                 * If the transition is from bus power to local power, all
     466                 * is good and we may signal the parent hub that we don't
     467                 * need the power.
     468                 * If the transition is from local power to bus power
     469                 * the hub should turn off all the ports and devices need
     470                 * to be reinitialized taking into account the limited power
     471                 * that is now available.
     472                 * There is no support for power distribution in HelenOS,
     473                 * (or other OSes/hub devices that I've seen) so this is not
     474                 * implemented.
     475                 * Just ACK the change.
     476                 */
     477                const int ret = usb_request_clear_feature(
     478                    control_pipe, USB_REQUEST_TYPE_CLASS,
     479                    USB_REQUEST_RECIPIENT_DEVICE,
     480                    USB_HUB_FEATURE_C_HUB_LOCAL_POWER, 0);
     481                if (opResult != EOK) {
     482                        usb_log_error("Failed to clear hub power change "
     483                            "flag: %s.\n", str_error(ret));
     484                }
     485        }
     486}
     487/*----------------------------------------------------------------------------*/
    472488/**
    473489 * callback called from hub polling fibril when the fibril terminates
    474490 *
    475  * Should perform a cleanup - deletes hub_info.
     491 * Does not perform cleanup, just marks the hub as not running.
    476492 * @param device usb device afected
    477493 * @param was_error indicates that the fibril is stoped due to an error
    478  * @param data pointer to usb_hub_info_t structure
     494 * @param data pointer to usb_hub_dev_t structure
    479495 */
    480496static void usb_hub_polling_terminated_callback(usb_device_t *device,
    481     bool was_error, void *data) {
    482         usb_hub_info_t * hub = data;
     497    bool was_error, void *data)
     498{
     499        usb_hub_dev_t *hub = data;
    483500        assert(hub);
    484501
    … …  
    494511         */
    495512        if (hub->pending_ops_count > 0) {
    496                 fibril_mutex_lock(&hub->port_mutex);
    497                 size_t port;
    498                 for (port = 0; port < hub->port_count; port++) {
    499                         usb_hub_port_t *the_port = hub->ports + port;
    500                         fibril_mutex_lock(&the_port->reset_mutex);
    501                         the_port->reset_completed = true;
    502                         the_port->reset_okay = false;
    503                         fibril_condvar_broadcast(&the_port->reset_cv);
    504                         fibril_mutex_unlock(&the_port->reset_mutex);
    505                 }
    506                 fibril_mutex_unlock(&hub->port_mutex);
     513                for (size_t port = 0; port < hub->port_count; ++port) {
     514                        usb_hub_port_reset_fail(&hub->ports[port]);
     515                }
    507516        }
    508517        /* And now wait for them. */
    … …  
    512521        }
    513522        fibril_mutex_unlock(&hub->pending_ops_mutex);
    514 
    515         usb_device_destroy(hub->usb_device);
    516 
    517         free(hub->ports);
    518         free(hub);
    519 }
    520 
    521 
    522 
    523 
     523        hub->running = false;
     524}
    524525/**
    525526 * @}
Note: See TracChangeset for help on using the changeset viewer.