Ignore:
Timestamp:
2011-04-07T09:53:12Z (14 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
d41f301
Parents:
c4e0b47 (diff), 41c1f7b (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 development/ changes

File:
1 moved

Legend:

Unmodified
Added
Removed

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

    rc4e0b47 r97ab321  
    11/*
    22 * Copyright (c) 2011 Jan Vesely
    3  * All rights reserved.
     3 * All rights eps.
    44 *
    55 * Redistribution and use in source and binary forms, with or without
    … …  
    2727 */
    2828
     29#include <bool.h>
    2930#include <assert.h>
    3031#include <errno.h>
    31 #include <usb/host/bandwidth.h>
    32 
     32
     33#include <usb/host/usb_endpoint_manager.h>
     34
     35#define BUCKET_COUNT 7
     36
     37#define MAX_KEYS (3)
    3338typedef struct {
    34         usb_address_t address;
    35         usb_endpoint_t endpoint;
    36         usb_direction_t direction;
    37 } __attribute__((aligned (sizeof(unsigned long)))) transfer_t;
    38 /*----------------------------------------------------------------------------*/
    39 typedef struct {
    40         transfer_t transfer;
    4139        link_t link;
    42         bool used;
    43         size_t required;
    44 } transfer_status_t;
    45 /*----------------------------------------------------------------------------*/
    46 #define BUCKET_COUNT 7
    47 #define MAX_KEYS (sizeof(transfer_t) / sizeof(unsigned long))
    48 /*----------------------------------------------------------------------------*/
    49 static hash_index_t transfer_hash(unsigned long key[])
     40        size_t bw;
     41        endpoint_t *ep;
     42} node_t;
     43/*----------------------------------------------------------------------------*/
     44static hash_index_t node_hash(unsigned long key[])
    5045{
    5146        hash_index_t hash = 0;
    … …  
    5853}
    5954/*----------------------------------------------------------------------------*/
    60 static int transfer_compare(
    61     unsigned long key[], hash_count_t keys, link_t *item)
     55static int node_compare(unsigned long key[], hash_count_t keys, link_t *item)
    6256{
    6357        assert(item);
    64         transfer_status_t *status =
    65             hash_table_get_instance(item, transfer_status_t, link);
    66         const size_t bytes =
    67             keys < MAX_KEYS ? keys * sizeof(unsigned long) : sizeof(transfer_t);
    68         return bcmp(key, &status->transfer, bytes);
    69 }
    70 /*----------------------------------------------------------------------------*/
    71 static void transfer_remove(link_t *item)
     58        node_t *node = hash_table_get_instance(item, node_t, link);
     59        assert(node);
     60        assert(node->ep);
     61        bool match = true;
     62        switch (keys) {
     63        case 3:
     64                match = match && (key[2] == node->ep->direction);
     65        case 2:
     66                match = match && (key[1] == (unsigned long)node->ep->endpoint);
     67        case 1:
     68                match = match && (key[0] == (unsigned long)node->ep->address);
     69                break;
     70        default:
     71                match = false;
     72        }
     73        return match;
     74}
     75/*----------------------------------------------------------------------------*/
     76static void node_remove(link_t *item)
    7277{
    7378        assert(item);
    74         transfer_status_t *status =
    75             hash_table_get_instance(item, transfer_status_t, link);
    76         assert(status);
    77         free(status);
    78 }
    79 /*----------------------------------------------------------------------------*/
    80 hash_table_operations_t op = {
    81         .hash = transfer_hash,
    82         .compare = transfer_compare,
    83         .remove_callback = transfer_remove,
     79        node_t *node = hash_table_get_instance(item, node_t, link);
     80        endpoint_destroy(node->ep);
     81        free(node);
     82}
     83/*----------------------------------------------------------------------------*/
     84static hash_table_operations_t op = {
     85        .hash = node_hash,
     86        .compare = node_compare,
     87        .remove_callback = node_remove,
    8488};
    8589/*----------------------------------------------------------------------------*/
    … …  
    120124}
    121125/*----------------------------------------------------------------------------*/
    122 int bandwidth_init(bandwidth_t *instance, size_t bandwidth,
    123     size_t (*usage_fnc)(usb_speed_t, usb_transfer_type_t, size_t, size_t))
     126int usb_endpoint_manager_init(usb_endpoint_manager_t *instance,
     127    size_t available_bandwidth)
    124128{
    125129        assert(instance);
    126130        fibril_mutex_initialize(&instance->guard);
    127         instance->free = bandwidth;
    128         instance->usage_fnc = usage_fnc;
     131        fibril_condvar_initialize(&instance->change);
     132        instance->free_bw = available_bandwidth;
    129133        bool ht =
    130             hash_table_create(&instance->reserved, BUCKET_COUNT, MAX_KEYS, &op);
     134            hash_table_create(&instance->ep_table, BUCKET_COUNT, MAX_KEYS, &op);
    131135        return ht ? EOK : ENOMEM;
    132136}
    133137/*----------------------------------------------------------------------------*/
    134 void bandwidth_destroy(bandwidth_t *instance)
    135 {
    136         hash_table_destroy(&instance->reserved);
    137 }
    138 /*----------------------------------------------------------------------------*/
    139 int bandwidth_reserve(bandwidth_t *instance, usb_address_t address,
    140     usb_endpoint_t endpoint, usb_direction_t direction, usb_speed_t speed,
    141     usb_transfer_type_t transfer_type, size_t max_packet_size, size_t size,
    142     unsigned interval)
    143 {
    144         if (transfer_type != USB_TRANSFER_ISOCHRONOUS &&
    145             transfer_type != USB_TRANSFER_INTERRUPT) {
    146                 return ENOTSUP;
    147         }
    148 
    149         assert(instance);
    150         assert(instance->usage_fnc);
    151 
    152         transfer_t trans = {
    153                 .address = address,
    154                 .endpoint = endpoint,
    155                 .direction = direction,
    156         };
     138void usb_endpoint_manager_destroy(usb_endpoint_manager_t *instance)
     139{
     140        hash_table_destroy(&instance->ep_table);
     141}
     142/*----------------------------------------------------------------------------*/
     143int usb_endpoint_manager_register_ep(usb_endpoint_manager_t *instance,
     144    endpoint_t *ep, size_t data_size)
     145{
     146        assert(ep);
     147        size_t bw = bandwidth_count_usb11(ep->speed, ep->transfer_type,
     148            data_size, ep->max_packet_size);
     149        assert(instance);
     150
     151        unsigned long key[MAX_KEYS] =
     152            {ep->address, ep->endpoint, ep->direction};
    157153        fibril_mutex_lock(&instance->guard);
    158         const size_t required =
    159             instance->usage_fnc(speed, transfer_type, size, max_packet_size);
    160 
    161         if (required > instance->free) {
     154
     155        link_t *item =
     156            hash_table_find(&instance->ep_table, key);
     157        if (item != NULL) {
     158                fibril_mutex_unlock(&instance->guard);
     159                return EEXISTS;
     160        }
     161
     162        if (bw > instance->free_bw) {
    162163                fibril_mutex_unlock(&instance->guard);
    163164                return ENOSPC;
    164165        }
    165166
    166         link_t *item =
    167             hash_table_find(&instance->reserved, (unsigned long*)&trans);
    168         if (item != NULL) {
    169                 fibril_mutex_unlock(&instance->guard);
    170                 return EEXISTS;
    171         }
    172 
    173         transfer_status_t *status = malloc(sizeof(transfer_status_t));
    174         if (status == NULL) {
     167        node_t *node = malloc(sizeof(node_t));
     168        if (node == NULL) {
    175169                fibril_mutex_unlock(&instance->guard);
    176170                return ENOMEM;
    177171        }
    178172
    179         status->transfer = trans;
    180         status->required = required;
    181         status->used = false;
    182         link_initialize(&status->link);
    183 
    184         hash_table_insert(&instance->reserved,
    185             (unsigned long*)&status->transfer, &status->link);
    186         instance->free -= required;
     173        node->bw = bw;
     174        node->ep = ep;
     175        link_initialize(&node->link);
     176
     177        hash_table_insert(&instance->ep_table, key, &node->link);
     178        instance->free_bw -= bw;
    187179        fibril_mutex_unlock(&instance->guard);
     180        fibril_condvar_broadcast(&instance->change);
    188181        return EOK;
    189         /* TODO: compute bandwidth used */
    190 }
    191 /*----------------------------------------------------------------------------*/
    192 int bandwidth_release(bandwidth_t *instance, usb_address_t address,
    193     usb_endpoint_t endpoint, usb_direction_t direction)
    194 {
    195         assert(instance);
    196         transfer_t trans = {
    197                 .address = address,
    198                 .endpoint = endpoint,
    199                 .direction = direction,
    200         };
     182}
     183/*----------------------------------------------------------------------------*/
     184int usb_endpoint_manager_unregister_ep(usb_endpoint_manager_t *instance,
     185    usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction)
     186{
     187        assert(instance);
     188        unsigned long key[MAX_KEYS] = {address, endpoint, direction};
     189
    201190        fibril_mutex_lock(&instance->guard);
    202         link_t *item =
    203             hash_table_find(&instance->reserved, (unsigned long*)&trans);
     191        link_t *item = hash_table_find(&instance->ep_table, key);
    204192        if (item == NULL) {
    205193                fibril_mutex_unlock(&instance->guard);
    … …  
    207195        }
    208196
    209         transfer_status_t *status =
    210             hash_table_get_instance(item, transfer_status_t, link);
    211 
    212         instance->free += status->required;
    213 
    214         hash_table_remove(&instance->reserved,
    215             (unsigned long*)&trans, MAX_KEYS);
     197        node_t *node = hash_table_get_instance(item, node_t, link);
     198        instance->free_bw += node->bw;
     199        hash_table_remove(&instance->ep_table, key, MAX_KEYS);
    216200
    217201        fibril_mutex_unlock(&instance->guard);
     202        fibril_condvar_broadcast(&instance->change);
    218203        return EOK;
    219         /* TODO: compute bandwidth freed */
    220 }
    221 /*----------------------------------------------------------------------------*/
    222 int bandwidth_use(bandwidth_t *instance, usb_address_t address,
    223     usb_endpoint_t endpoint, usb_direction_t direction)
    224 {
    225         assert(instance);
    226         transfer_t trans = {
    227                 .address = address,
    228                 .endpoint = endpoint,
    229                 .direction = direction,
    230         };
     204}
     205/*----------------------------------------------------------------------------*/
     206endpoint_t * usb_endpoint_manager_get_ep(usb_endpoint_manager_t *instance,
     207    usb_address_t address, usb_endpoint_t endpoint, usb_direction_t direction,
     208    size_t *bw)
     209{
     210        assert(instance);
     211        unsigned long key[MAX_KEYS] = {address, endpoint, direction};
     212
    231213        fibril_mutex_lock(&instance->guard);
    232         link_t *item =
    233             hash_table_find(&instance->reserved, (unsigned long*)&trans);
    234         int ret = EOK;
    235         if (item != NULL) {
    236                 transfer_status_t *status =
    237                     hash_table_get_instance(item, transfer_status_t, link);
    238                 assert(status);
    239                 if (status->used) {
    240                         ret = EINPROGRESS;
    241                 }
    242                 status->used = true;
    243         } else {
    244                 ret = EINVAL;
    245         }
     214        link_t *item = hash_table_find(&instance->ep_table, key);
     215        if (item == NULL) {
     216                fibril_mutex_unlock(&instance->guard);
     217                return NULL;
     218        }
     219        node_t *node = hash_table_get_instance(item, node_t, link);
     220        if (bw)
     221                *bw = node->bw;
     222
    246223        fibril_mutex_unlock(&instance->guard);
    247         return ret;
    248 }
    249 /*----------------------------------------------------------------------------*/
    250 int bandwidth_free(bandwidth_t *instance, usb_address_t address,
    251     usb_endpoint_t endpoint, usb_direction_t direction)
    252 {
    253         assert(instance);
    254         transfer_t trans = {
    255                 .address = address,
    256                 .endpoint = endpoint,
    257                 .direction = direction,
    258         };
    259         fibril_mutex_lock(&instance->guard);
    260         link_t *item =
    261             hash_table_find(&instance->reserved, (unsigned long*)&trans);
    262         int ret = EOK;
    263         if (item != NULL) {
    264                 transfer_status_t *status =
    265                     hash_table_get_instance(item, transfer_status_t, link);
    266                 assert(status);
    267                 if (!status->used) {
    268                         ret = ENOENT;
    269                 }
    270                 status->used = false;
    271         } else {
    272                 ret = EINVAL;
    273         }
    274         fibril_mutex_unlock(&instance->guard);
    275         return ret;
    276 }
     224        return node->ep;
     225}
Note: See TracChangeset for help on using the changeset viewer.