Changes in / [0e45e7f:48fe0c9] in mainline


Ignore:
Location:
uspace
Files:
6 added
5 deleted
9 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/Makefile

    r0e45e7f r48fe0c9  
    3333
    3434SOURCES = \
    35         hc_iface.c \
     35        iface.c \
    3636        batch.c \
    3737        main.c \
    38         ohci_hc.c \
    39         ohci_rh.c \
     38        hc.c \
     39        root_hub.c \
    4040        pci.c
    4141

  • uspace/drv/ohci/batch.c

    r0e45e7f r48fe0c9  
    3939
    4040#include "batch.h"
     41#include "utils/malloc32.h"
     42
     43static void batch_call_in_and_dispose(batch_t *instance);
     44static void batch_call_out_and_dispose(batch_t *instance);
    4145
    4246#define DEFAULT_ERROR_COUNT 3
     47batch_t * batch_get(
     48    ddf_fun_t *fun,
     49                usb_target_t target,
     50    usb_transfer_type_t transfer_type,
     51                size_t max_packet_size,
     52    usb_speed_t speed,
     53                char *buffer,
     54                size_t buffer_size,
     55                char *setup_buffer,
     56                size_t setup_size,
     57    usbhc_iface_transfer_in_callback_t func_in,
     58    usbhc_iface_transfer_out_callback_t func_out,
     59                void *arg,
     60                device_keeper_t *manager
     61                )
     62{
     63#define CHECK_NULL_DISPOSE_RETURN(ptr, message...) \
     64        if (ptr == NULL) { \
     65                usb_log_error(message); \
     66                if (instance) { \
     67                        batch_dispose(instance); \
     68                } \
     69                return NULL; \
     70        } else (void)0
    4371
     72        batch_t *instance = malloc(sizeof(batch_t));
     73        CHECK_NULL_DISPOSE_RETURN(instance,
     74            "Failed to allocate batch instance.\n");
     75        batch_init(instance, target, transfer_type, speed, max_packet_size,
     76            buffer, NULL, buffer_size, NULL, setup_size, func_in,
     77            func_out, arg, fun, NULL);
     78
     79        if (buffer_size > 0) {
     80                instance->transport_buffer = malloc32(buffer_size);
     81                CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
     82                    "Failed to allocate device accessible buffer.\n");
     83        }
     84
     85        if (setup_size > 0) {
     86                instance->setup_buffer = malloc32(setup_size);
     87                CHECK_NULL_DISPOSE_RETURN(instance->setup_buffer,
     88                    "Failed to allocate device accessible setup buffer.\n");
     89                memcpy(instance->setup_buffer, setup_buffer, setup_size);
     90        }
     91
     92
     93        return instance;
     94}
     95/*----------------------------------------------------------------------------*/
     96void batch_dispose(batch_t *instance)
     97{
     98        assert(instance);
     99        free32(instance->transport_buffer);
     100        free32(instance->setup_buffer);
     101        free(instance);
     102}
     103/*----------------------------------------------------------------------------*/
     104void batch_control_write(batch_t *instance)
     105{
     106        assert(instance);
     107        /* We are data out, we are supposed to provide data */
     108        memcpy(instance->transport_buffer, instance->buffer,
     109            instance->buffer_size);
     110        instance->next_step = batch_call_out_and_dispose;
     111        /* TODO: implement */
     112        usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
     113}
     114/*----------------------------------------------------------------------------*/
     115void batch_control_read(batch_t *instance)
     116{
     117        assert(instance);
     118        instance->next_step = batch_call_in_and_dispose;
     119        /* TODO: implement */
     120        usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
     121}
     122/*----------------------------------------------------------------------------*/
     123void batch_interrupt_in(batch_t *instance)
     124{
     125        assert(instance);
     126        instance->direction = USB_DIRECTION_IN;
     127        instance->next_step = batch_call_in_and_dispose;
     128        /* TODO: implement */
     129        usb_log_debug("Batch(%p) INTERRUPT IN initialized.\n", instance);
     130}
     131/*----------------------------------------------------------------------------*/
     132void batch_interrupt_out(batch_t *instance)
     133{
     134        assert(instance);
     135        instance->direction = USB_DIRECTION_OUT;
     136        /* We are data out, we are supposed to provide data */
     137        memcpy(instance->transport_buffer, instance->buffer,
     138            instance->buffer_size);
     139        instance->next_step = batch_call_out_and_dispose;
     140        /* TODO: implement */
     141        usb_log_debug("Batch(%p) INTERRUPT OUT initialized.\n", instance);
     142}
     143/*----------------------------------------------------------------------------*/
     144void batch_bulk_in(batch_t *instance)
     145{
     146        assert(instance);
     147        instance->direction = USB_DIRECTION_IN;
     148        instance->next_step = batch_call_in_and_dispose;
     149        /* TODO: implement */
     150        usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
     151}
     152/*----------------------------------------------------------------------------*/
     153void batch_bulk_out(batch_t *instance)
     154{
     155        assert(instance);
     156        instance->direction = USB_DIRECTION_IN;
     157        instance->next_step = batch_call_in_and_dispose;
     158        /* TODO: implement */
     159        usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
     160}
     161/*----------------------------------------------------------------------------*/
     162/** Helper function calls callback and correctly disposes of batch structure.
     163 *
     164 * @param[in] instance Batch structure to use.
     165 */
     166void batch_call_in_and_dispose(batch_t *instance)
     167{
     168        assert(instance);
     169        batch_call_in(instance);
     170        batch_dispose(instance);
     171}
     172/*----------------------------------------------------------------------------*/
     173/** Helper function calls callback and correctly disposes of batch structure.
     174 *
     175 * @param[in] instance Batch structure to use.
     176 */
     177void batch_call_out_and_dispose(batch_t *instance)
     178{
     179        assert(instance);
     180        batch_call_out(instance);
     181        batch_dispose(instance);
     182}
    44183/**
    45184 * @}

  • uspace/drv/ohci/iface.h

    r0e45e7f r48fe0c9  
    4040#define NAME "ohci"
    4141
    42 extern usbhc_iface_t ohci_hc_iface;
     42extern usbhc_iface_t hc_iface;
    4343
    4444#endif

  • uspace/drv/ohci/main.c

    r0e45e7f r48fe0c9  
    4545#include "pci.h"
    4646#include "iface.h"
    47 #include "ohci_hc.h"
     47#include "hc.h"
    4848
    4949static int ohci_add_device(ddf_dev_t *device);
     50static int get_hc_handle(ddf_fun_t *fun, devman_handle_t *handle)
     51{
     52        assert(handle);
     53  assert(fun != NULL);
     54
     55  *handle = fun->handle;
     56  return EOK;
     57}
     58/*----------------------------------------------------------------------------*/
     59static int get_address(
     60    ddf_fun_t *fun, devman_handle_t handle, usb_address_t *address)
     61{
     62        assert(fun);
     63        device_keeper_t *manager = &fun_to_hc(fun)->manager;
     64  usb_address_t addr = device_keeper_find(manager, handle);
     65  if (addr < 0) {
     66    return addr;
     67  }
     68
     69  if (address != NULL) {
     70    *address = addr;
     71  }
     72
     73  return EOK;
     74}
    5075/*----------------------------------------------------------------------------*/
    5176/** IRQ handling callback, identifies device
    … …  
    5883{
    5984        assert(dev);
    60         ohci_hc_t *hc = (ohci_hc_t*)dev->driver_data;
     85        hc_t *hc = (hc_t*)dev->driver_data;
    6186        assert(hc);
    62         ohci_hc_interrupt(hc, 0);
     87        hc_interrupt(hc, 0);
    6388}
    6489/*----------------------------------------------------------------------------*/
    … …  
    7196        .driver_ops = &ohci_driver_ops
    7297};
     98/*----------------------------------------------------------------------------*/
     99static usb_iface_t hc_usb_iface = {
     100        .get_address = get_address,
     101        .get_hc_handle = get_hc_handle,
     102};
     103/*----------------------------------------------------------------------------*/
    73104static ddf_dev_ops_t hc_ops = {
    74         .interfaces[USBHC_DEV_IFACE] = &ohci_hc_iface,
    75 };
    76 
     105        .interfaces[USB_DEV_IFACE] = &hc_usb_iface,
     106        .interfaces[USBHC_DEV_IFACE] = &hc_iface,
     107};
    77108/*----------------------------------------------------------------------------*/
    78109/** Initializes a new ddf driver instance of OHCI hcd.
    … …  
    105136            "Failed(%d) disable legacy USB: %s.\n", ret, str_error(ret));
    106137
    107         ohci_hc_t *hcd = malloc(sizeof(ohci_hc_t));
     138        hc_t *hcd = malloc(sizeof(hc_t));
    108139        if (hcd == NULL) {
    109140                usb_log_error("Failed to allocate OHCI driver.\n");
    … …  
    129160        }
    130161
    131         ret = ohci_hc_init(hcd, hc_fun, mem_reg_base, mem_reg_size, interrupts);
     162        ret = hc_init(hcd, hc_fun, device, mem_reg_base, mem_reg_size, interrupts);
    132163        if (ret != EOK) {
    133164                usb_log_error("Failed to initialize OHCI driver.\n");
    … …  
    148179        hc_fun->driver_data = hcd;
    149180
    150         /* TODO: register interrupt handler */
     181        fid_t later = fibril_create((int(*)(void*))hc_register_hub, hcd);
     182        fibril_add_ready(later);
    151183
    152184        usb_log_info("Controlling new OHCI device `%s' (handle %llu).\n",

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

    r0e45e7f r48fe0c9  
    183183
    184184                        device_keeper_set_toggle(data->manager,
    185                             instance->target, td_toggle(&data->tds[i]));
     185                            instance->target, instance->direction,
     186                            td_toggle(&data->tds[i]));
    186187                        if (i > 0)
    187188                                goto substract_ret;
    … …  
    238239{
    239240        assert(instance);
     241        instance->direction = USB_DIRECTION_IN;
    240242        batch_data(instance, USB_PID_IN);
    241243        instance->next_step = batch_call_in_and_dispose;
    … …  
    252254{
    253255        assert(instance);
     256        instance->direction = USB_DIRECTION_OUT;
    254257        /* We are data out, we are supposed to provide data */
    255258        memcpy(instance->transport_buffer, instance->buffer,
    … …  
    270273        assert(instance);
    271274        batch_data(instance, USB_PID_IN);
     275        instance->direction = USB_DIRECTION_IN;
    272276        instance->next_step = batch_call_in_and_dispose;
    273277        usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
    … …  
    283287{
    284288        assert(instance);
     289        instance->direction = USB_DIRECTION_OUT;
    285290        /* We are data out, we are supposed to provide data */
    286291        memcpy(instance->transport_buffer, instance->buffer,
    … …  
    306311
    307312        const bool low_speed = instance->speed == USB_SPEED_LOW;
    308         int toggle = device_keeper_get_toggle(data->manager, instance->target);
     313        int toggle = device_keeper_get_toggle(
     314            data->manager, instance->target, instance->direction);
    309315        assert(toggle == 0 || toggle == 1);
    310316
    … …  
    337343        }
    338344        td_set_ioc(&data->tds[packet - 1]);
    339         device_keeper_set_toggle(data->manager, instance->target, toggle);
     345        device_keeper_set_toggle(data->manager, instance->target,
     346            instance->direction, toggle);
    340347}
    341348/*----------------------------------------------------------------------------*/

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

    r0e45e7f r48fe0c9  
    4646        usb_transfer_type_t transfer_type;
    4747        usb_speed_t speed;
     48        usb_direction_t direction;
    4849        usbhc_iface_transfer_in_callback_t callback_in;
    4950        usbhc_iface_transfer_out_callback_t callback_out;

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

    r0e45e7f r48fe0c9  
    4444        usb_speed_t speed;
    4545        bool occupied;
    46         uint16_t toggle_status;
     46        uint16_t toggle_status[2];
    4747        devman_handle_t handle;
    4848};
    … …  
    6363
    6464void device_keeper_reset_if_need(
    65     device_keeper_t *instance, usb_target_t target, const unsigned char *setup_data);
     65    device_keeper_t *instance, usb_target_t target,
     66    const unsigned char *setup_data);
    6667
    67 int device_keeper_get_toggle(device_keeper_t *instance, usb_target_t target);
     68int device_keeper_get_toggle(
     69    device_keeper_t *instance, usb_target_t target, usb_direction_t direction);
    6870
    69 int device_keeper_set_toggle(
    70     device_keeper_t *instance, usb_target_t target, bool toggle);
     71int device_keeper_set_toggle(device_keeper_t *instance,
     72    usb_target_t target, usb_direction_t direction, bool toggle);
    7173
    7274usb_address_t device_keeper_request(

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

    r0e45e7f r48fe0c9  
    6262        instance->transfer_type = transfer_type;
    6363        instance->speed = speed;
     64        instance->direction = USB_DIRECTION_BOTH;
    6465        instance->callback_in = func_in;
    6566        instance->callback_out = func_out;

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

    r0e45e7f r48fe0c9  
    5555                instance->devices[i].occupied = false;
    5656                instance->devices[i].handle = 0;
    57                 instance->devices[i].toggle_status = 0;
     57                instance->devices[i].toggle_status[0] = 0;
     58                instance->devices[i].toggle_status[1] = 0;
    5859        }
    5960}
    … …  
    118119                if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) {
    119120                        /* endpoint number is < 16, thus first byte is enough */
    120                         instance->devices[target.address].toggle_status &=
     121                        instance->devices[target.address].toggle_status[0] &=
     122                            ~(1 << data[4]);
     123                        instance->devices[target.address].toggle_status[1] &=
    121124                            ~(1 << data[4]);
    122125                }
    … …  
    127130                /* target must be device */
    128131                if ((data[0] & 0xf) == 0) {
    129                         instance->devices[target.address].toggle_status = 0;
     132                        instance->devices[target.address].toggle_status[0] = 0;
     133                        instance->devices[target.address].toggle_status[1] = 0;
    130134                }
    131135        break;
    … …  
    140144 * @return Error code
    141145 */
    142 int device_keeper_get_toggle(device_keeper_t *instance, usb_target_t target)
    143 {
    144         assert(instance);
     146int device_keeper_get_toggle(
     147    device_keeper_t *instance, usb_target_t target, usb_direction_t direction)
     148{
     149        assert(instance);
     150        /* only control pipes are bi-directional and those do not need toggle */
     151        if (direction == USB_DIRECTION_BOTH)
     152                return ENOENT;
    145153        int ret;
    146154        fibril_mutex_lock(&instance->guard);
    … …  
    151159                ret = EINVAL;
    152160        } else {
    153                 ret = (instance->devices[target.address].toggle_status
     161                ret = (instance->devices[target.address].toggle_status[direction]
    154162                        >> target.endpoint) & 1;
    155163        }
    … …  
    165173 * @return Error code.
    166174 */
    167 int device_keeper_set_toggle(
    168     device_keeper_t *instance, usb_target_t target, bool toggle)
    169 {
    170         assert(instance);
     175int device_keeper_set_toggle(device_keeper_t *instance,
     176    usb_target_t target, usb_direction_t direction, bool toggle)
     177{
     178        assert(instance);
     179        /* only control pipes are bi-directional and those do not need toggle */
     180        if (direction == USB_DIRECTION_BOTH)
     181                return ENOENT;
    171182        int ret;
    172183        fibril_mutex_lock(&instance->guard);
    … …  
    178189        } else {
    179190                if (toggle) {
    180                         instance->devices[target.address].toggle_status |= (1 << target.endpoint);
     191                        instance->devices[target.address].toggle_status[direction]
     192                            |= (1 << target.endpoint);
    181193                } else {
    182                         instance->devices[target.address].toggle_status &= ~(1 << target.endpoint);
     194                        instance->devices[target.address].toggle_status[direction]
     195                            &= ~(1 << target.endpoint);
    183196                }
    184197                ret = EOK;
    … …  
    215228        instance->devices[new_address].occupied = true;
    216229        instance->devices[new_address].speed = speed;
    217         instance->devices[new_address].toggle_status = 0;
     230        instance->devices[new_address].toggle_status[0] = 0;
     231        instance->devices[new_address].toggle_status[1] = 0;
    218232        instance->last_address = new_address;
    219233        fibril_mutex_unlock(&instance->guard);
Note: See TracChangeset for help on using the changeset viewer.