Changeset 6832245 in mainline for uspace/lib/usbhost/src/bus.c


Ignore:
Timestamp:
2017-12-14T23:01:57Z (8 years ago)
Author:
Ondřej Hlavatý <aearsis@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
837d53d
Parents:
bd05140
git-author:
Ondřej Hlavatý <aearsis@…> (2017-12-14 23:01:54)
git-committer:
Ondřej Hlavatý <aearsis@…> (2017-12-14 23:01:57)
Message:

usbhost bus: refactor the bus ops

This way, method names better represent the entity it is working with.
Their semantics was shifted a bit.

Regarding the tree of structures:

bus ← device ← endpoint ← batch

Previously, devices were kept in DDF function nodes, and endpoints had
pointer to the bus and device. Now, devices have pointer to bus,
endpoints don't.

Pointer to hcd_t in bus is WIP, and will be removed.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/usbhost/src/bus.c

    rbd05140 r6832245  
    4646 * Initializes the bus structure.
    4747 */
    48 void bus_init(bus_t *bus, size_t device_size)
    49 {
    50         assert(bus);
     48void bus_init(bus_t *bus, hcd_t *hcd, size_t device_size)
     49{
     50        assert(bus);
     51        assert(hcd);
    5152        assert(device_size >= sizeof(device_t));
    5253        memset(bus, 0, sizeof(bus_t));
    5354
    5455        fibril_mutex_initialize(&bus->guard);
     56        bus->hcd = hcd;
    5557        bus->device_size = device_size;
    5658}
    5759
    58 int device_init(device_t *dev)
    59 {
     60int bus_device_init(device_t *dev, bus_t *bus)
     61{
     62        assert(bus);
     63        assert(bus->hcd);
     64
    6065        memset(dev, 0, sizeof(*dev));
     66
     67        dev->bus = bus;
    6168
    6269        link_initialize(&dev->link);
    … …  
    6774}
    6875
    69 int device_set_default_name(device_t *dev)
     76int bus_device_set_default_name(device_t *dev)
    7077{
    7178        assert(dev);
    … …  
    7986}
    8087
    81 int bus_enumerate_device(bus_t *bus, hcd_t *hcd, device_t *dev)
    82 {
    83         assert(bus);
    84         assert(hcd);
    85         assert(dev);
    86 
    87         if (!bus->ops.enumerate_device)
    88                 return ENOTSUP;
    89 
    90         return bus->ops.enumerate_device(bus, hcd, dev);
    91 }
    92 
    93 int bus_remove_device(bus_t *bus, hcd_t *hcd, device_t *dev)
    94 {
    95         assert(bus);
    96         assert(dev);
    97 
    98         if (!bus->ops.remove_device)
    99                 return ENOTSUP;
    100 
    101         return bus->ops.remove_device(bus, hcd, dev);
    102 }
    103 
    104 int bus_online_device(bus_t *bus, hcd_t *hcd, device_t *dev)
    105 {
    106         assert(bus);
    107         assert(hcd);
    108         assert(dev);
    109 
    110         if (!bus->ops.online_device)
    111                 return ENOTSUP;
    112 
    113         return bus->ops.online_device(bus, hcd, dev);
    114 }
    115 
    116 int bus_offline_device(bus_t *bus, hcd_t *hcd, device_t *dev)
    117 {
    118         assert(bus);
    119         assert(hcd);
    120         assert(dev);
    121 
    122         if (!bus->ops.offline_device)
    123                 return ENOTSUP;
    124 
    125         return bus->ops.offline_device(bus, hcd, dev);
    126 }
    127 
    128 int bus_add_endpoint(bus_t *bus, device_t *device, const usb_endpoint_desc_t *desc, endpoint_t **out_ep)
    129 {
    130         assert(bus);
     88int bus_device_enumerate(device_t *dev)
     89{
     90        assert(dev);
     91
     92        const bus_ops_t *ops = BUS_OPS_LOOKUP(dev->bus->ops, device_enumerate);
     93        if (!ops)
     94                return ENOTSUP;
     95
     96        return ops->device_enumerate(dev);
     97}
     98
     99int bus_device_remove(device_t *dev)
     100{
     101        assert(dev);
     102
     103        const bus_ops_t *ops = BUS_OPS_LOOKUP(dev->bus->ops, device_remove);
     104
     105        if (!ops)
     106                return ENOTSUP;
     107
     108        return ops->device_remove(dev);
     109}
     110
     111int bus_device_online(device_t *dev)
     112{
     113        assert(dev);
     114
     115        const bus_ops_t *ops = BUS_OPS_LOOKUP(dev->bus->ops, device_online);
     116        if (!ops)
     117                return ENOTSUP;
     118
     119        return ops->device_online(dev);
     120}
     121
     122int bus_device_offline(device_t *dev)
     123{
     124        assert(dev);
     125
     126        const bus_ops_t *ops = BUS_OPS_LOOKUP(dev->bus->ops, device_offline);
     127        if (!ops)
     128                return ENOTSUP;
     129
     130        return ops->device_offline(dev);
     131}
     132
     133int bus_endpoint_add(device_t *device, const usb_endpoint_desc_t *desc, endpoint_t **out_ep)
     134{
     135        int err;
    131136        assert(device);
     137
     138        bus_t *bus = device->bus;
    132139
    133140        if (desc->max_packet_size == 0 || desc->packets == 0) {
    … …  
    136143        }
    137144
    138         fibril_mutex_lock(&bus->guard);
    139 
    140         int err = ENOMEM;
    141         endpoint_t *ep = bus->ops.create_endpoint(bus);
     145        const bus_ops_t *create_ops = BUS_OPS_LOOKUP(bus->ops, endpoint_create);
     146        const bus_ops_t *register_ops = BUS_OPS_LOOKUP(bus->ops, endpoint_register);
     147        if (!create_ops || !register_ops)
     148                return ENOTSUP;
     149
     150        endpoint_t *ep = create_ops->endpoint_create(device, desc);
    142151        if (!ep)
    143                 goto err;
    144 
    145         /* Bus reference */
     152                return ENOMEM;
     153
     154        /* Temporary reference */
    146155        endpoint_add_ref(ep);
    147156
    148         if ((err = bus->ops.register_endpoint(bus, device, ep, desc)))
    149                 goto err_ep;
     157        fibril_mutex_lock(&bus->guard);
     158        err = register_ops->endpoint_register(ep);
     159        fibril_mutex_unlock(&bus->guard);
    150160
    151161        if (out_ep) {
     162                /* Exporting reference */
    152163                endpoint_add_ref(ep);
    153164                *out_ep = ep;
    154165        }
    155166
    156         fibril_mutex_unlock(&bus->guard);
    157         return EOK;
    158 
    159 err_ep:
     167        /* Temporary reference */
    160168        endpoint_del_ref(ep);
    161 err:
    162         fibril_mutex_unlock(&bus->guard);
    163169        return err;
    164170}
    … …  
    166172/** Searches for an endpoint. Returns a reference.
    167173 */
    168 endpoint_t *bus_find_endpoint(bus_t *bus, device_t *device, usb_target_t endpoint, usb_direction_t dir)
    169 {
    170         assert(bus);
    171 
    172         fibril_mutex_lock(&bus->guard);
    173         endpoint_t *ep = bus->ops.find_endpoint(bus, device, endpoint, dir);
     174endpoint_t *bus_find_endpoint(device_t *device, usb_target_t endpoint, usb_direction_t dir)
     175{
     176        assert(device);
     177
     178        bus_t *bus = device->bus;
     179
     180        const bus_ops_t *ops = BUS_OPS_LOOKUP(bus->ops, device_find_endpoint);
     181        if (!ops)
     182                return NULL;
     183
     184        fibril_mutex_lock(&bus->guard);
     185        endpoint_t *ep = ops->device_find_endpoint(device, endpoint, dir);
    174186        if (ep) {
    175187                /* Exporting reference */
    … …  
    181193}
    182194
    183 int bus_remove_endpoint(bus_t *bus, endpoint_t *ep)
    184 {
    185         assert(bus);
     195int bus_endpoint_remove(endpoint_t *ep)
     196{
    186197        assert(ep);
    187198
    188         fibril_mutex_lock(&bus->guard);
    189         const int r = bus->ops.unregister_endpoint(bus, ep);
     199        bus_t *bus = endpoint_get_bus(ep);
     200
     201        const bus_ops_t *ops = BUS_OPS_LOOKUP(ep->device->bus->ops, endpoint_unregister);
     202        if (!ops)
     203                return ENOTSUP;
     204
     205        fibril_mutex_lock(&bus->guard);
     206        const int r = ops->endpoint_unregister(ep);
    190207        fibril_mutex_unlock(&bus->guard);
    191208
    … …  
    203220        assert(bus);
    204221
    205         if (!bus->ops.reserve_default_address)
    206                 return ENOTSUP;
    207 
    208         fibril_mutex_lock(&bus->guard);
    209         const int r = bus->ops.reserve_default_address(bus, speed);
     222        const bus_ops_t *ops = BUS_OPS_LOOKUP(bus->ops, reserve_default_address);
     223        if (!ops)
     224                return ENOTSUP;
     225
     226        fibril_mutex_lock(&bus->guard);
     227        const int r = ops->reserve_default_address(bus, speed);
    210228        fibril_mutex_unlock(&bus->guard);
    211229        return r;
    … …  
    216234        assert(bus);
    217235
    218         /* If this op is not set, allow everything */
    219         if (!bus->ops.release_default_address)
    220                 return ENOTSUP;
    221 
    222         fibril_mutex_lock(&bus->guard);
    223         const int r = bus->ops.release_default_address(bus);
     236        const bus_ops_t *ops = BUS_OPS_LOOKUP(bus->ops, release_default_address);
     237        if (!ops)
     238                return ENOTSUP;
     239
     240        fibril_mutex_lock(&bus->guard);
     241        const int r = ops->release_default_address(bus);
    224242        fibril_mutex_unlock(&bus->guard);
    225243        return r;
    … …  
    230248        assert(bus);
    231249
    232         if (!bus->ops.reset_toggle)
    233                 return ENOTSUP;
    234 
    235         fibril_mutex_lock(&bus->guard);
    236         const int r = bus->ops.reset_toggle(bus, target, all);
     250        const bus_ops_t *ops = BUS_OPS_LOOKUP(bus->ops, reset_toggle);
     251        if (!ops)
     252                return ENOTSUP;
     253
     254        fibril_mutex_lock(&bus->guard);
     255        const int r = ops->reset_toggle(bus, target, all);
    237256        fibril_mutex_unlock(&bus->guard);
    238257        return r;
    239 }
    240 
    241 size_t bus_count_bw(endpoint_t *ep, size_t size)
    242 {
    243         assert(ep);
    244 
    245         fibril_mutex_lock(&ep->guard);
    246         const size_t bw = ep->bus->ops.count_bw(ep, size);
    247         fibril_mutex_unlock(&ep->guard);
    248         return bw;
    249258}
    250259
Note: See TracChangeset for help on using the changeset viewer.