Changes in / [5542b83:969585f] in mainline


Ignore:
Location:
uspace
Files:
2 deleted
8 edited

Legend:

Unmodified
Added
Removed

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

    r5542b83 r969585f  
    239239        usb_log_debug("Initialized device manager.\n");
    240240
    241         ret = bandwidth_init(&instance->bandwidth, BANDWIDTH_AVAILABLE_USB11,
    242             bandwidth_count_usb11);
    243         assert(ret == true);
    244 
    245241        return EOK;
    246242#undef CHECK_RET_DEST_CMDS_RETURN
    … …  
    329325        if (!usb_is_allowed(
    330326            low_speed, batch->transfer_type, batch->max_packet_size)) {
    331                 usb_log_error("Invalid USB transfer specified %s %d %zu.\n",
    332                     usb_str_speed(batch->speed), batch->transfer_type,
     327                usb_log_warning(
     328                    "Invalid USB transfer specified %s SPEED %d %zu.\n",
     329                    low_speed ? "LOW" : "FULL" , batch->transfer_type,
    333330                    batch->max_packet_size);
    334331                return ENOTSUP;
    335332        }
    336         /* Check available bandwidth */
    337         if (batch->transfer_type == USB_TRANSFER_INTERRUPT ||
    338             batch->transfer_type == USB_TRANSFER_ISOCHRONOUS) {
    339                 int ret =
    340                     bandwidth_use(&instance->bandwidth, batch->target.address,
    341                     batch->target.endpoint, batch->direction);
    342                 if (ret != EOK) {
    343                         usb_log_warning("Failed(%d) to use reserved bw: %s.\n",
    344                             ret, str_error(ret));
    345                 }
    346         }
     333        /* TODO: check available bandwidth here */
    347334
    348335        transfer_list_t *list =
    … …  
    351338        if (batch->transfer_type == USB_TRANSFER_CONTROL) {
    352339                usb_device_keeper_use_control(
    353                     &instance->manager, batch->target);
     340                    &instance->manager, batch->target.address);
    354341        }
    355342        transfer_list_add_batch(list, batch);
    … …  
    371358{
    372359        assert(instance);
    373 //      status |= 1; //Uncomment to work around qemu hang
    374360        /* TODO: Resume interrupts are not supported */
    375361        /* Lower 2 bits are transaction error and transaction complete */
    … …  
    390376                        usb_transfer_batch_t *batch =
    391377                            list_get_instance(item, usb_transfer_batch_t, link);
    392                         switch (batch->transfer_type)
    393                         {
    394                         case USB_TRANSFER_CONTROL:
     378                        if (batch->transfer_type == USB_TRANSFER_CONTROL) {
    395379                                usb_device_keeper_release_control(
    396                                     &instance->manager, batch->target);
    397                                 break;
    398                         case USB_TRANSFER_INTERRUPT:
    399                         case USB_TRANSFER_ISOCHRONOUS: {
    400                                 int ret = bandwidth_free(&instance->bandwidth,
    401                                     batch->target.address,
    402                                     batch->target.endpoint,
    403                                     batch->direction);
    404                                 if (ret != EOK)
    405                                         usb_log_warning("Failed(%d) to free "
    406                                             "reserved bw: %s.\n", ret,
    407                                             str_error(ret));
    408                                 }
    409                         default:
    410                                 break;
     380                                    &instance->manager, batch->target.address);
    411381                        }
    412382                        batch->next_step(batch);

  • uspace/drv/uhci-hcd/hc.h

    r5542b83 r969585f  
    4343#include <usbhc_iface.h>
    4444#include <usb/host/device_keeper.h>
    45 #include <usb/host/bandwidth.h>
    4645
    4746#include "batch.h"
    … …  
    8584typedef struct hc {
    8685        usb_device_keeper_t manager;
    87         bandwidth_t bandwidth;
    8886
    8987        regs_t *registers;

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

    r5542b83 r969585f  
    128128}
    129129/*----------------------------------------------------------------------------*/
    130 static int register_endpoint(
    131     ddf_fun_t *fun, usb_address_t address, usb_endpoint_t endpoint,
    132     usb_transfer_type_t transfer_type, usb_direction_t direction,
    133     size_t max_packet_size, unsigned int interval)
    134 {
    135         hc_t *hc = fun_to_hc(fun);
    136         assert(hc);
    137         const usb_speed_t speed =
    138             usb_device_keeper_get_speed(&hc->manager, address);
    139         size_t size = max_packet_size;
    140 
    141         usb_log_debug("Register endpoint %d:%d %s %s(%d) %zu(%zu) %u.\n",
    142             address, endpoint, usb_str_transfer_type(transfer_type),
    143             usb_str_speed(speed), direction, size, max_packet_size, interval);
    144         return bandwidth_reserve(&hc->bandwidth, address, endpoint, direction,
    145             speed, transfer_type, max_packet_size, size, interval);
    146 }
    147 /*----------------------------------------------------------------------------*/
    148 static int unregister_endpoint(
    149     ddf_fun_t *fun, usb_address_t address,
    150     usb_endpoint_t endpoint, usb_direction_t direction)
    151 {
    152         hc_t *hc = fun_to_hc(fun);
    153         assert(hc);
    154         usb_log_debug("Unregister endpoint %d:%d %d.\n",
    155             address, endpoint, direction);
    156         return bandwidth_release(&hc->bandwidth, address, endpoint, direction);
    157 }
    158 /*----------------------------------------------------------------------------*/
    159130/** Interrupt out transaction interface function
    160131 *
    … …  
    394365        .release_address = release_address,
    395366
    396         .register_endpoint = register_endpoint,
    397         .unregister_endpoint = unregister_endpoint,
    398 
    399367        .interrupt_out = interrupt_out,
    400368        .interrupt_in = interrupt_in,

  • uspace/lib/c/generic/adt/hash_table.c

    r5542b83 r969585f  
    5454 *
    5555 */
    56 bool hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
     56int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
    5757    hash_table_operations_t *op)
    5858{

  • uspace/lib/c/include/adt/hash_table.h

    r5542b83 r969585f  
    3838#include <adt/list.h>
    3939#include <unistd.h>
    40 #include <bool.h>
    4140
    4241typedef unsigned long hash_count_t;
    … …  
    8483    list_get_instance((item), type, member)
    8584
    86 extern bool hash_table_create(hash_table_t *, hash_count_t, hash_count_t,
     85extern int hash_table_create(hash_table_t *, hash_count_t, hash_count_t,
    8786    hash_table_operations_t *);
    8887extern void hash_table_insert(hash_table_t *, unsigned long [], link_t *);

  • uspace/lib/usb/Makefile

    r5542b83 r969585f  
    5353        src/hidreport.c \
    5454        src/host/device_keeper.c \
    55         src/host/batch.c \
    56         src/host/bandwidth.c
     55        src/host/batch.c
    5756
    5857include $(USPACE_PREFIX)/Makefile.common

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

    r5542b83 r969585f  
    5151        usb_speed_t speed;
    5252        bool occupied;
    53         uint16_t control_used;
     53        bool control_used;
    5454        uint16_t toggle_status[2];
    5555        devman_handle_t handle;
    … …  
    9999
    100100void usb_device_keeper_use_control(usb_device_keeper_t *instance,
    101     usb_target_t target);
     101    usb_address_t address);
    102102
    103103void usb_device_keeper_release_control(usb_device_keeper_t *instance,
    104     usb_target_t target);
     104    usb_address_t address);
    105105
    106106#endif

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

    r5542b83 r969585f  
    5454        for (; i < USB_ADDRESS_COUNT; ++i) {
    5555                instance->devices[i].occupied = false;
    56                 instance->devices[i].control_used = 0;
     56                instance->devices[i].control_used = false;
    5757                instance->devices[i].handle = 0;
    5858                instance->devices[i].toggle_status[0] = 0;
    … …  
    311311/*----------------------------------------------------------------------------*/
    312312void usb_device_keeper_use_control(usb_device_keeper_t *instance,
    313     usb_target_t target)
    314 {
    315         assert(instance);
    316         const uint16_t ep = 1 << target.endpoint;
    317         fibril_mutex_lock(&instance->guard);
    318         while (instance->devices[target.address].control_used & ep) {
     313    usb_address_t address)
     314{
     315        assert(instance);
     316        fibril_mutex_lock(&instance->guard);
     317        while (instance->devices[address].control_used) {
    319318                fibril_condvar_wait(&instance->change, &instance->guard);
    320319        }
    321         instance->devices[target.address].control_used |= ep;
     320        instance->devices[address].control_used = true;
    322321        fibril_mutex_unlock(&instance->guard);
    323322}
    324323/*----------------------------------------------------------------------------*/
    325324void usb_device_keeper_release_control(usb_device_keeper_t *instance,
    326     usb_target_t target)
    327 {
    328         assert(instance);
    329         const uint16_t ep = 1 << target.endpoint;
    330         fibril_mutex_lock(&instance->guard);
    331         assert((instance->devices[target.address].control_used & ep) != 0);
    332         instance->devices[target.address].control_used &= ~ep;
     325    usb_address_t address)
     326{
     327        assert(instance);
     328        fibril_mutex_lock(&instance->guard);
     329        instance->devices[address].control_used = false;
    333330        fibril_mutex_unlock(&instance->guard);
    334331        fibril_condvar_signal(&instance->change);
Note: See TracChangeset for help on using the changeset viewer.