Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/bus/usb/vhc/transfer.c

    rb7fd2a0 r1d758fc  
    3131#include <usb/debug.h>
    3232#include <usbvirt/device.h>
     33#include <usb/host/bandwidth.h>
     34#include <usb/host/endpoint.h>
     35#include <usb/host/usb_transfer_batch.h>
    3336#include <usbvirt/ipc.h>
    3437#include "vhcd.h"
    … …  
    3740static bool is_set_address_transfer(vhc_transfer_t *transfer)
    3841{
    39         if (transfer->batch->ep->endpoint != 0) {
    40                 return false;
    41         }
    42         if (transfer->batch->ep->transfer_type != USB_TRANSFER_CONTROL) {
    43                 return false;
    44         }
    45         if (usb_transfer_batch_direction(transfer->batch) != USB_DIRECTION_OUT) {
    46                 return false;
    47         }
    48         const usb_device_request_setup_packet_t *setup =
    49             (void*)transfer->batch->setup_buffer;
     42        if (transfer->batch.target.endpoint != 0) {
     43                return false;
     44        }
     45        if (transfer->batch.ep->transfer_type != USB_TRANSFER_CONTROL) {
     46                return false;
     47        }
     48        if (transfer->batch.dir != USB_DIRECTION_OUT) {
     49                return false;
     50        }
     51        const usb_device_request_setup_packet_t *setup
     52                = &transfer->batch.setup.packet;
    5053        if (setup->request_type != 0) {
    5154                return false;
    … …  
    6265{
    6366        errno_t rc;
    64        
    65         const usb_direction_t dir = usb_transfer_batch_direction(batch);
     67
     68        const usb_direction_t dir = batch->dir;
    6669
    6770        if (batch->ep->transfer_type == USB_TRANSFER_CONTROL) {
    6871                if (dir == USB_DIRECTION_IN) {
    6972                        rc = usbvirt_control_read(dev,
    70                             batch->setup_buffer, batch->setup_size,
    71                             batch->buffer, batch->buffer_size,
     73                            batch->setup.buffer, USB_SETUP_PACKET_SIZE,
     74                            batch->dma_buffer.virt, batch->size,
    7275                            actual_data_size);
    7376                } else {
    7477                        assert(dir == USB_DIRECTION_OUT);
    7578                        rc = usbvirt_control_write(dev,
    76                             batch->setup_buffer, batch->setup_size,
    77                             batch->buffer, batch->buffer_size);
     79                            batch->setup.buffer, USB_SETUP_PACKET_SIZE,
     80                            batch->dma_buffer.virt, batch->size);
    7881                }
    7982        } else {
    … …  
    8184                        rc = usbvirt_data_in(dev, batch->ep->transfer_type,
    8285                            batch->ep->endpoint,
    83                             batch->buffer, batch->buffer_size,
     86                            batch->dma_buffer.virt, batch->size,
    8487                            actual_data_size);
    8588                } else {
    … …  
    8790                        rc = usbvirt_data_out(dev, batch->ep->transfer_type,
    8891                            batch->ep->endpoint,
    89                             batch->buffer, batch->buffer_size);
     92                            batch->dma_buffer.virt, batch->size);
    9093                }
    9194        }
    … …  
    99102        errno_t rc;
    100103
    101         const usb_direction_t dir = usb_transfer_batch_direction(batch);
     104        const usb_direction_t dir = batch->dir;
    102105
    103106        if (batch->ep->transfer_type == USB_TRANSFER_CONTROL) {
    104107                if (dir == USB_DIRECTION_IN) {
    105108                        rc = usbvirt_ipc_send_control_read(sess,
    106                             batch->setup_buffer, batch->setup_size,
    107                             batch->buffer, batch->buffer_size,
     109                            batch->setup.buffer, USB_SETUP_PACKET_SIZE,
     110                            batch->dma_buffer.virt, batch->size,
    108111                            actual_data_size);
    109112                } else {
    110113                        assert(dir == USB_DIRECTION_OUT);
    111114                        rc = usbvirt_ipc_send_control_write(sess,
    112                             batch->setup_buffer, batch->setup_size,
    113                             batch->buffer, batch->buffer_size);
     115                            batch->setup.buffer, USB_SETUP_PACKET_SIZE,
     116                            batch->dma_buffer.virt, batch->size);
    114117                }
    115118        } else {
    … …  
    117120                        rc = usbvirt_ipc_send_data_in(sess, batch->ep->endpoint,
    118121                            batch->ep->transfer_type,
    119                             batch->buffer, batch->buffer_size,
     122                            batch->dma_buffer.virt, batch->size,
    120123                            actual_data_size);
    121124                } else {
    … …  
    123126                        rc = usbvirt_ipc_send_data_out(sess, batch->ep->endpoint,
    124127                            batch->ep->transfer_type,
    125                             batch->buffer, batch->buffer_size);
     128                            batch->dma_buffer.virt, batch->size);
    126129                }
    127130        }
    … …  
    147150        assert(outcome != ENAK);
    148151        assert(transfer);
    149         assert(transfer->batch);
    150         usb_transfer_batch_finish_error(transfer->batch, NULL,
    151             data_transfer_size, outcome);
    152         usb_transfer_batch_destroy(transfer->batch);
    153         free(transfer);
    154 }
     152        transfer->batch.error = outcome;
     153        transfer->batch.transferred_size = data_transfer_size;
     154        usb_transfer_batch_finish(&transfer->batch);
     155}
     156
     157static usb_transfer_batch_t *batch_create(endpoint_t *ep)
     158{
     159        vhc_transfer_t *transfer = calloc(1, sizeof(vhc_transfer_t));
     160        usb_transfer_batch_init(&transfer->batch, ep);
     161        link_initialize(&transfer->link);
     162        return &transfer->batch;
     163}
     164
     165static int device_enumerate(device_t *device)
     166{
     167        vhc_data_t *vhc = bus_to_vhc(device->bus);
     168        return usb2_bus_device_enumerate(&vhc->bus_helper, device);
     169}
     170
     171static int endpoint_register(endpoint_t *endpoint)
     172{
     173        vhc_data_t *vhc = bus_to_vhc(endpoint->device->bus);
     174        return usb2_bus_endpoint_register(&vhc->bus_helper, endpoint);
     175}
     176
     177static void endpoint_unregister(endpoint_t *endpoint)
     178{
     179        vhc_data_t *vhc = bus_to_vhc(endpoint->device->bus);
     180        usb2_bus_endpoint_unregister(&vhc->bus_helper, endpoint);
     181
     182        // TODO: abort transfer?
     183}
     184
     185static const bus_ops_t vhc_bus_ops = {
     186        .batch_create = batch_create,
     187        .batch_schedule = vhc_schedule,
     188
     189        .device_enumerate = device_enumerate,
     190        .endpoint_register = endpoint_register,
     191        .endpoint_unregister = endpoint_unregister,
     192};
    155193
    156194errno_t vhc_init(vhc_data_t *instance)
    … …  
    159197        list_initialize(&instance->devices);
    160198        fibril_mutex_initialize(&instance->guard);
    161         instance->magic = 0xDEADBEEF;
     199        bus_init(&instance->bus, sizeof(device_t));
     200        usb2_bus_helper_init(&instance->bus_helper, &bandwidth_accounting_usb11);
     201        instance->bus.ops = &vhc_bus_ops;
    162202        return virthub_init(&instance->hub, "root hub");
    163203}
    164204
    165 errno_t vhc_schedule(hcd_t *hcd, usb_transfer_batch_t *batch)
    166 {
    167         assert(hcd);
     205errno_t vhc_schedule(usb_transfer_batch_t *batch)
     206{
    168207        assert(batch);
    169         vhc_data_t *vhc = hcd_get_driver_data(hcd);
     208        vhc_transfer_t *transfer = (vhc_transfer_t *) batch;
     209        vhc_data_t *vhc = bus_to_vhc(endpoint_get_bus(batch->ep));
    170210        assert(vhc);
    171 
    172         vhc_transfer_t *transfer = malloc(sizeof(vhc_transfer_t));
    173         if (!transfer)
    174                 return ENOMEM;
    175         link_initialize(&transfer->link);
    176         transfer->batch = batch;
    177211
    178212        fibril_mutex_lock(&vhc->guard);
    … …  
    182216        list_foreach(vhc->devices, link, vhc_virtdev_t, dev) {
    183217                fibril_mutex_lock(&dev->guard);
    184                 if (dev->address == transfer->batch->ep->address) {
     218                if (dev->address == transfer->batch.target.address) {
    185219                        if (!targets) {
    186220                                list_append(&transfer->link, &dev->transfer_queue);
    … …  
    194228       
    195229        if (targets > 1)
    196                 usb_log_warning("Transfer would be accepted by more devices!\n");
     230                usb_log_warning("Transfer would be accepted by more devices!");
    197231
    198232        return targets ? EOK : ENOENT;
    … …  
    217251                size_t data_transfer_size = 0;
    218252                if (dev->dev_sess) {
    219                         rc = process_transfer_remote(transfer->batch,
     253                        rc = process_transfer_remote(&transfer->batch,
    220254                            dev->dev_sess, &data_transfer_size);
    221255                } else if (dev->dev_local != NULL) {
    222                         rc = process_transfer_local(transfer->batch,
     256                        rc = process_transfer_local(&transfer->batch,
    223257                            dev->dev_local, &data_transfer_size);
    224258                } else {
    225                         usb_log_warning("Device has no remote phone nor local node.\n");
     259                        usb_log_warning("Device has no remote phone nor local node.");
    226260                        rc = ESTALL;
    227261                }
    228262
    229                 usb_log_debug2("Transfer %p processed: %s.\n",
     263                usb_log_debug2("Transfer %p processed: %s.",
    230264                    transfer, str_error(rc));
    231265
    … …  
    234268                        if (is_set_address_transfer(transfer)) {
    235269                                usb_device_request_setup_packet_t *setup =
    236                                     (void*) transfer->batch->setup_buffer;
     270                                    (void*) transfer->batch.setup.buffer;
    237271                                dev->address = setup->value;
    238                                 usb_log_debug2("Address changed to %d\n",
     272                                usb_log_debug2("Address changed to %d",
    239273                                    dev->address);
    240274                        }
Note: See TracChangeset for help on using the changeset viewer.