Changeset aec2ad4 in mainline for uspace/drv


Ignore:
Timestamp:
2011-02-04T11:48:33Z (15 years ago)
Author:
Matus Dekanek <smekideki@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
103a3626
Parents:
ba5ab09 (diff), 3597dab (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 from usb/development

Location:
uspace/drv
Files:
5 added
11 edited
8 moved

Legend:

Unmodified
Added
Removed

  • uspace/drv/uhci/Makefile

    rba5ab09 raec2ad4  
    3434SOURCES = \
    3535        main.c \
     36        pci.c \
    3637        transfers.c
    3738

  • uspace/drv/uhci/main.c

    rba5ab09 raec2ad4  
    3030#include <usb/debug.h>
    3131#include <errno.h>
     32#include <str_error.h>
    3233#include <driver.h>
    3334#include "uhci.h"
    … …  
    5556        usb_dprintf(NAME, 1, "uhci_add_device() called\n");
    5657        device->ops = &uhci_ops;
     58
     59        uintptr_t io_reg_base;
     60        size_t io_reg_size;
     61        int irq;
     62
     63        int rc = pci_get_my_registers(device,
     64            &io_reg_base, &io_reg_size, &irq);
     65
     66        if (rc != EOK) {
     67                fprintf(stderr,
     68                    NAME ": failed to get I/O registers addresses: %s.\n",
     69                    str_error(rc));
     70                return rc;
     71        }
     72
     73        usb_dprintf(NAME, 2, "I/O regs at 0x%X (size %zu), IRQ %d.\n",
     74            io_reg_base, io_reg_size, irq);
    5775
    5876        /*

  • uspace/drv/uhci/uhci.h

    rba5ab09 raec2ad4  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbuhci
    3030 * @{
    3131 */
    … …  
    4242usbhc_iface_t uhci_iface;
    4343
     44int pci_get_my_registers(device_t *, uintptr_t *, size_t *, int *);
     45
    4446#endif
    4547/**

  • uspace/drv/usbhid/Makefile

    rba5ab09 raec2ad4  
    11#
    2 # Copyright (c) 2010 Vojtech Horky
     2# Copyright (c) 2010-2011 Vojtech Horky
    33# All rights reserved.
    44#
    … …  
    2929USPACE_PREFIX = ../..
    3030LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBUSB_PREFIX)/libusb.a
    31 EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBUSB_PREFIX)/include
    32 BINARY = usbkbd
     31EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBUSB_PREFIX)/include -I.
     32BINARY = usbhid
     33
     34STOLEN_LAYOUT_SOURCES = \
     35        layout/us_qwerty.c \
     36        layout/us_dvorak.c \
     37        layout/cz.c
    3338
    3439SOURCES = \
    3540        main.c \
    3641        descparser.c \
    37         descdump.c
     42        descdump.c \
     43        conv.c \
     44        $(STOLEN_LAYOUT_SOURCES)
     45
     46EXTRA_CLEAN = $(STOLEN_LAYOUT_SOURCES)
     47
     48SRV_KBD = $(USPACE_PREFIX)/srv/hid/kbd
    3849
    3950include $(USPACE_PREFIX)/Makefile.common
     51
     52layout/%.c: $(SRV_KBD)/layout/%.c
     53        ln -sfn ../$< $@

  • uspace/drv/usbhid/descdump.c

    rba5ab09 raec2ad4  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
     28
    2829/** @addtogroup drvusbhid
    2930 * @{
     31 */
     32/** @file
     33 * Descriptor dumping.
    3034 */
    3135

  • uspace/drv/usbhid/descdump.h

    rba5ab09 raec2ad4  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
     28
    2829/** @addtogroup drvusbhid
    2930 * @{
    3031 */
     32/** @file
     33 * Descriptor dumping.
     34 */
     35
    3136#ifndef USBHID_DESCDUMP_H_
    3237#define USBHID_DESCDUMP_H_
    3338
    34 #include <usb/classes/hid.h>
     39#include "hid.h"
    3540
    3641void dump_standard_configuration_descriptor(

  • uspace/drv/usbhid/descparser.c

    rba5ab09 raec2ad4  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
     28
    2829/** @addtogroup drvusbhid
    2930 * @{
     31 */
     32/** @file
     33 * Descriptor parser.
    3034 */
    3135

  • uspace/drv/usbhid/descparser.h

    rba5ab09 raec2ad4  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
     28
    2829/** @addtogroup drvusbhid
    2930 * @{
     31 */
     32/** @file
     33 * Descriptor parser.
    3034 */
    3135
    … …  
    3337#define USBHID_DESCPARSER_H_
    3438
    35 #include <usb/classes/hid.h>
     39#include "hid.h"
    3640
    3741int usbkbd_parse_descriptors(const uint8_t *data, size_t size,

  • uspace/drv/usbhid/layout.h

    rba5ab09 raec2ad4  
    11/*
    2  * Copyright (c) 2010 Vojtech Horky
     2 * Copyright (c) 2009 Jiri Svoboda
     3 * Copyright (c) 2011 Lubos Slovak
     4 * (copied from /uspace/srv/hid/kbd/include/layout.h)
    35 * All rights reserved.
    46 *
    … …  
    2729 */
    2830
    29 /** @addtogroup drvusbvhc
     31/** @addtogroup drvusbhid
    3032 * @{
    3133 */
    3234/** @file
    33  * @brief Debugging support.
     35 * Keyboard layout.
    3436 */
    35 #include <stdio.h>
    36 #include <ipc/ipc.h>
    37 #include <usb/debug.h>
    3837
    39 #include "vhcd.h"
     38#ifndef USBHID_LAYOUT_H_
     39#define USBHID_LAYOUT_H_
    4040
     41#include <sys/types.h>
     42#include <io/console.h>
    4143
    42 /** Debug print informing of invalid call.
    43  */
    44 void dprintf_inval_call(int level, ipc_call_t call, sysarg_t phone_hash)
    45 {
    46         dprintf(level, "phone%#x: invalid call [%u (%u, %u, %u, %u, %u)]",
    47             phone_hash,
    48             IPC_GET_IMETHOD(call),
    49             IPC_GET_ARG1(call), IPC_GET_ARG2(call), IPC_GET_ARG3(call),
    50             IPC_GET_ARG4(call), IPC_GET_ARG5(call));
    51 }
     44typedef struct {
     45        void (*reset)(void);
     46        wchar_t (*parse_ev)(console_event_t *);
     47} layout_op_t;
     48
     49extern layout_op_t us_qwerty_op;
     50extern layout_op_t us_dvorak_op;
     51extern layout_op_t cz_op;
     52
     53#endif
    5254
    5355/**

  • uspace/drv/usbhid/main.c

    rba5ab09 raec2ad4  
    11/*
    22 * Copyright (c) 2010 Vojtech Horky
     3 * Copyright (c) 2011 Lubos Slovak
    34 * All rights reserved.
    45 *
    … …  
    2627 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2728 */
     29
    2830/** @addtogroup drvusbhid
    2931 * @{
    3032 */
     33/**
     34 * @file
     35 * Main routines of USB HID driver.
     36 */
     37
    3138#include <usb/usbdrv.h>
    3239#include <driver.h>
    … …  
    3643#include <io/console.h>
    3744#include <errno.h>
     45#include <str_error.h>
    3846#include <fibril.h>
    3947#include <usb/classes/hid.h>
    4048#include <usb/classes/hidparser.h>
    41 #include <usb/devreq.h>
     49#include <usb/request.h>
    4250#include <usb/descriptor.h>
     51#include <io/console.h>
     52#include "hid.h"
    4353#include "descparser.h"
    4454#include "descdump.h"
     55#include "conv.h"
     56#include "layout.h"
    4557
    4658#define BUFFER_SIZE 32
    47 #define NAME "usbkbd"
     59#define NAME "usbhid"
    4860
    4961#define GUESSED_POLL_ENDPOINT 1
    … …  
    91103
    92104/*
     105 * TODO: Move somewhere else
     106 */
     107/*
     108#define BYTES_PER_LINE 12
     109
     110static void dump_buffer(const char *msg, const uint8_t *buffer, size_t length)
     111{
     112        printf("%s\n", msg);
     113       
     114        size_t i;
     115        for (i = 0; i < length; i++) {
     116                printf("  0x%02X", buffer[i]);
     117                if (((i > 0) && (((i+1) % BYTES_PER_LINE) == 0))
     118                    || (i + 1 == length)) {
     119                        printf("\n");
     120                }
     121        }
     122}
     123*/
     124/*
     125 * Copy-paste from srv/hid/kbd/generic/kbd.c
     126 */
     127
     128/** Currently active modifiers.
     129 *
     130 * TODO: put to device?
     131 */
     132static unsigned mods = KM_NUM_LOCK;
     133
     134/** Currently pressed lock keys. We track these to tackle autorepeat. 
     135 *
     136 * TODO: put to device?
     137 */
     138static unsigned lock_keys;
     139
     140#define NUM_LAYOUTS 3
     141
     142static layout_op_t *layout[NUM_LAYOUTS] = {
     143        &us_qwerty_op,
     144        &us_dvorak_op,
     145        &cz_op
     146};
     147
     148static int active_layout = 0;
     149
     150static void kbd_push_ev(int type, unsigned int key)
     151{
     152        console_event_t ev;
     153        unsigned mod_mask;
     154
     155        // TODO: replace by our own parsing?? or are the key codes identical??
     156        switch (key) {
     157        case KC_LCTRL: mod_mask = KM_LCTRL; break;
     158        case KC_RCTRL: mod_mask = KM_RCTRL; break;
     159        case KC_LSHIFT: mod_mask = KM_LSHIFT; break;
     160        case KC_RSHIFT: mod_mask = KM_RSHIFT; break;
     161        case KC_LALT: mod_mask = KM_LALT; break;
     162        case KC_RALT: mod_mask = KM_RALT; break;
     163        default: mod_mask = 0; break;
     164        }
     165
     166        if (mod_mask != 0) {
     167                if (type == KEY_PRESS)
     168                        mods = mods | mod_mask;
     169                else
     170                        mods = mods & ~mod_mask;
     171        }
     172
     173        switch (key) {
     174        case KC_CAPS_LOCK: mod_mask = KM_CAPS_LOCK; break;
     175        case KC_NUM_LOCK: mod_mask = KM_NUM_LOCK; break;
     176        case KC_SCROLL_LOCK: mod_mask = KM_SCROLL_LOCK; break;
     177        default: mod_mask = 0; break;
     178        }
     179
     180        if (mod_mask != 0) {
     181                if (type == KEY_PRESS) {
     182                        /*
     183                         * Only change lock state on transition from released
     184                         * to pressed. This prevents autorepeat from messing
     185                         * up the lock state.
     186                         */
     187                        mods = mods ^ (mod_mask & ~lock_keys);
     188                        lock_keys = lock_keys | mod_mask;
     189
     190                        /* Update keyboard lock indicator lights. */
     191                        // TODO
     192                        //kbd_ctl_set_ind(mods);
     193                } else {
     194                        lock_keys = lock_keys & ~mod_mask;
     195                }
     196        }
     197/*
     198        printf("type: %d\n", type);
     199        printf("mods: 0x%x\n", mods);
     200        printf("keycode: %u\n", key);
     201*/
     202       
     203        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
     204                key == KC_F1) {
     205                active_layout = 0;
     206                layout[active_layout]->reset();
     207                return;
     208        }
     209
     210        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
     211                key == KC_F2) {
     212                active_layout = 1;
     213                layout[active_layout]->reset();
     214                return;
     215        }
     216
     217        if (type == KEY_PRESS && (mods & KM_LCTRL) &&
     218                key == KC_F3) {
     219                active_layout = 2;
     220                layout[active_layout]->reset();
     221                return;
     222        }
     223       
     224        ev.type = type;
     225        ev.key = key;
     226        ev.mods = mods;
     227
     228        ev.c = layout[active_layout]->parse_ev(&ev);
     229
     230        printf("Sending key %d to the console\n", ev.key);
     231        assert(console_callback_phone != -1);
     232        async_msg_4(console_callback_phone, KBD_EVENT, ev.type, ev.key, ev.mods, ev.c);
     233}
     234/*
     235 * End of copy-paste
     236 */
     237
     238        /*
     239         * TODO:
     240         * 1) key press / key release - how does the keyboard notify about release?
     241         * 2) layouts (use the already defined), not important now
     242         * 3)
     243         */
     244
     245/*
    93246 * Callbacks for parser
    94247 */
    95248static void usbkbd_process_keycodes(const uint8_t *key_codes, size_t count,
    96                                     uint8_t modifiers, void *arg)
     249    uint8_t modifiers, void *arg)
    97250{
    98251        printf("Got keys: ");
    … …  
    100253        for (i = 0; i < count; ++i) {
    101254                printf("%d ", key_codes[i]);
     255                // TODO: Key press / release
     256
     257                // TODO: NOT WORKING
     258                unsigned int key = usbkbd_parse_scancode(key_codes[i]);
     259                kbd_push_ev(KEY_PRESS, key);
    102260        }
    103261        printf("\n");
    … …  
    122280               
    123281                // get the descriptor from the device
    124                 int rc = usb_drv_req_get_descriptor(kbd_dev->device->parent_phone,
    125                     kbd_dev->address, USB_REQUEST_TYPE_CLASS, USB_DESCTYPE_HID_REPORT,
    126                     0, i, kbd_dev->conf->interfaces[i].report_desc, length,
     282                int rc = usb_request_get_descriptor(&kbd_dev->ctrl_pipe,
     283                    USB_REQUEST_TYPE_CLASS, USB_DESCTYPE_HID_REPORT,
     284                    i, 0,
     285                    kbd_dev->conf->interfaces[i].report_desc, length,
    127286                    &actual_size);
    128287
    … …  
    145304        usb_standard_configuration_descriptor_t config_desc;
    146305       
    147         int rc = usb_drv_req_get_bare_configuration_descriptor(
    148             kbd_dev->device->parent_phone, kbd_dev->address, 0, &config_desc);
     306        int rc;
     307        rc = usb_request_get_bare_configuration_descriptor(&kbd_dev->ctrl_pipe,
     308            0, &config_desc);
    149309       
    150310        if (rc != EOK) {
    … …  
    160320        size_t transferred = 0;
    161321        // get full configuration descriptor
    162         rc = usb_drv_req_get_full_configuration_descriptor(
    163             kbd_dev->device->parent_phone, kbd_dev->address, 0, descriptors,
     322        rc = usb_request_get_full_configuration_descriptor(&kbd_dev->ctrl_pipe,
     323            0, descriptors,
    164324            config_desc.total_length, &transferred);
    165325       
    … …  
    208368static usb_hid_dev_kbd_t *usbkbd_init_device(device_t *dev)
    209369{
     370        int rc;
     371
    210372        usb_hid_dev_kbd_t *kbd_dev = (usb_hid_dev_kbd_t *)calloc(1,
    211373            sizeof(usb_hid_dev_kbd_t));
    … …  
    218380        kbd_dev->device = dev;
    219381
    220         // get phone to my HC and save it as my parent's phone
    221         // TODO: maybe not a good idea if DDF will use parent_phone
    222         int rc = kbd_dev->device->parent_phone = usb_drv_hc_connect_auto(dev, 0);
    223         if (rc < 0) {
    224                 printf("Problem setting phone to HC.\n");
    225                 free(kbd_dev);
    226                 return NULL;
    227         }
    228 
    229         rc = kbd_dev->address = usb_drv_get_my_address(dev->parent_phone, dev);
    230         if (rc < 0) {
    231                 printf("Problem getting address of the device.\n");
    232                 free(kbd_dev);
    233                 return NULL;
    234         }
    235 
    236         // doesn't matter now that we have no address
    237 //      if (kbd_dev->address < 0) {
    238 //              fprintf(stderr, NAME ": No device address!\n");
    239 //              free(kbd_dev);
    240 //              return NULL;
    241 //      }
    242 
    243         // default endpoint
    244         kbd_dev->poll_endpoint = GUESSED_POLL_ENDPOINT;
    245        
     382        /*
     383         * Initialize the backing connection to the host controller.
     384         */
     385        rc = usb_device_connection_initialize_from_device(&kbd_dev->wire, dev);
     386        if (rc != EOK) {
     387                printf("Problem initializing connection to device: %s.\n",
     388                    str_error(rc));
     389                goto error_leave;
     390        }
     391
     392        /*
     393         * Initialize device pipes.
     394         */
     395        rc = usb_endpoint_pipe_initialize_default_control(&kbd_dev->ctrl_pipe,
     396            &kbd_dev->wire);
     397        if (rc != EOK) {
     398                printf("Failed to initialize default control pipe: %s.\n",
     399                    str_error(rc));
     400                goto error_leave;
     401        }
     402
     403        rc = usb_endpoint_pipe_initialize(&kbd_dev->poll_pipe, &kbd_dev->wire,
     404            GUESSED_POLL_ENDPOINT, USB_TRANSFER_INTERRUPT, USB_DIRECTION_IN);
     405        if (rc != EOK) {
     406                printf("Failed to initialize interrupt in pipe: %s.\n",
     407                    str_error(rc));
     408                goto error_leave;
     409        }
     410
    246411        /*
    247412         * will need all descriptors:
    248          * 1) choose one configuration from configuration descriptors 
     413         * 1) choose one configuration from configuration descriptors
    249414         *    (set it to the device)
    250415         * 2) set endpoints from endpoint descriptors
    … …  
    252417
    253418        // TODO: get descriptors, parse descriptors and save endpoints
     419        usb_endpoint_pipe_start_session(&kbd_dev->ctrl_pipe);
    254420        usbkbd_process_descriptors(kbd_dev);
     421        usb_endpoint_pipe_end_session(&kbd_dev->ctrl_pipe);
    255422
    256423        return kbd_dev;
     424
     425error_leave:
     426        free(kbd_dev);
     427        return NULL;
    257428}
    258429
    … …  
    267438        //usb_hid_parse_report(kbd_dev->parser, buffer, actual_size, callbacks,
    268439        //    NULL);
    269         printf("Calling usb_hid_boot_keyboard_input_report()...\n)");
    270         usb_hid_boot_keyboard_input_report(buffer, actual_size, callbacks, NULL);
     440        printf("Calling usb_hid_boot_keyboard_input_report() with size %zu\n",
     441            actual_size);
     442        //dump_buffer("bufffer: ", buffer, actual_size);
     443        int rc = usb_hid_boot_keyboard_input_report(buffer, actual_size, callbacks,
     444            NULL);
     445        if (rc != EOK) {
     446                printf("Error in usb_hid_boot_keyboard_input_report(): %d\n", rc);
     447        }
    271448}
    272449
    273450static void usbkbd_poll_keyboard(usb_hid_dev_kbd_t *kbd_dev)
    274451{
    275         return;
    276        
    277         int rc;
    278         usb_handle_t handle;
     452        int rc, sess_rc;
    279453        uint8_t buffer[BUFFER_SIZE];
    280454        size_t actual_size;
    281         //usb_endpoint_t poll_endpoint = 1;
    282 
    283 //      usb_address_t my_address = usb_drv_get_my_address(dev->parent_phone,
    284 //          dev);
    285 //      if (my_address < 0) {
    286 //              return;
    287 //      }
    288 
    289         usb_target_t poll_target = {
    290                 .address = kbd_dev->address,
    291                 .endpoint = kbd_dev->poll_endpoint
    292         };
     455
     456        printf("Polling keyboard...\n");
    293457
    294458        while (true) {
    295                 async_usleep(1000 * 1000);
    296                 rc = usb_drv_async_interrupt_in(kbd_dev->device->parent_phone,
    297                     poll_target, buffer, BUFFER_SIZE, &actual_size, &handle);
     459                async_usleep(1000 * 1000 * 2);
     460
     461                sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->poll_pipe);
     462                if (sess_rc != EOK) {
     463                        printf("Failed to start a session: %s.\n",
     464                            str_error(sess_rc));
     465                        continue;
     466                }
     467
     468                rc = usb_endpoint_pipe_read(&kbd_dev->poll_pipe, buffer,
     469                    BUFFER_SIZE, &actual_size);
     470                sess_rc = usb_endpoint_pipe_end_session(&kbd_dev->poll_pipe);
    298471
    299472                if (rc != EOK) {
     473                        printf("Error polling the keyboard: %s.\n",
     474                            str_error(rc));
    300475                        continue;
    301476                }
    302477
    303                 rc = usb_drv_async_wait_for(handle);
    304                 if (rc != EOK) {
     478                if (sess_rc != EOK) {
     479                        printf("Error closing session: %s.\n",
     480                            str_error(sess_rc));
    305481                        continue;
    306482                }
    … …  
    311487                 */
    312488                if (actual_size == 0) {
     489                        printf("Keyboard returned NAK\n");
    313490                        continue;
    314491                }
    … …  
    317494                 * TODO: Process pressed keys.
    318495                 */
     496                printf("Calling usbkbd_process_interrupt_in()\n");
    319497                usbkbd_process_interrupt_in(kbd_dev, buffer, actual_size);
    320498        }
    … …  
    337515        // initialize device (get and process descriptors, get address, etc.)
    338516        usb_hid_dev_kbd_t *kbd_dev = usbkbd_init_device(dev);
     517        if (kbd_dev == NULL) {
     518                printf("Error while initializing device.\n");
     519                return -1;
     520        }
    339521
    340522        usbkbd_poll_keyboard(kbd_dev);

  • uspace/drv/vhc/Makefile

    rba5ab09 raec2ad4  
    4444        conndev.c \
    4545        connhost.c \
    46         debug.c \
    4746        devices.c \
    4847        hc.c \

  • uspace/drv/vhc/conndev.c

    rba5ab09 raec2ad4  
    9999                int rc = get_device_name(callback, devname, DEVICE_NAME_MAXLENGTH);
    100100
    101                 dprintf(0, "virtual device connected (name: %s, id: %x)",
     101                usb_log_info("New virtual device `%s' (id = %x).\n",
    102102                    rc == EOK ? devname : "<unknown>", dev->id);
    103103
    … …  
    122122        }
    123123
    124         dprintf(0, "virtual device disconnected (id: %x)", dev->id);
     124        usb_log_info("Virtual device disconnected (id = %x).\n", dev->id);
    125125        virtdev_destroy_device(dev);
    126126}

  • uspace/drv/vhc/connhost.c

    rba5ab09 raec2ad4  
    4242#include "hc.h"
    4343
     44
    4445typedef struct {
    4546        usb_direction_t direction;
    … …  
    4748        usbhc_iface_transfer_in_callback_t in_callback;
    4849        device_t *dev;
     50        size_t reported_size;
    4951        void *arg;
    5052} transfer_info_t;
    5153
     54typedef struct {
     55        usb_direction_t direction;
     56        usb_target_t target;
     57        usbhc_iface_transfer_out_callback_t out_callback;
     58        usbhc_iface_transfer_in_callback_t in_callback;
     59        device_t *dev;
     60        void *arg;
     61        void *data_buffer;
     62        size_t data_buffer_size;
     63} control_transfer_info_t;
     64
    5265static void universal_callback(void *buffer, size_t size,
    5366    usb_transaction_outcome_t outcome, void *arg)
    5467{
    5568        transfer_info_t *transfer = (transfer_info_t *) arg;
     69
     70        if (transfer->reported_size != (size_t) -1) {
     71                size = transfer->reported_size;
     72        }
    5673
    5774        switch (transfer->direction) {
    … …  
    84101        transfer->arg = arg;
    85102        transfer->dev = dev;
     103        transfer->reported_size = (size_t) -1;
     104
     105        return transfer;
     106}
     107
     108static void control_abort_prematurely(control_transfer_info_t *transfer,
     109    size_t size, usb_transaction_outcome_t outcome)
     110{
     111        switch (transfer->direction) {
     112                case USB_DIRECTION_IN:
     113                        transfer->in_callback(transfer->dev,
     114                            outcome, size,
     115                            transfer->arg);
     116                        break;
     117                case USB_DIRECTION_OUT:
     118                        transfer->out_callback(transfer->dev,
     119                            outcome,
     120                            transfer->arg);
     121                        break;
     122                default:
     123                        assert(false && "unreachable");
     124                        break;
     125        }
     126}
     127
     128static void control_callback_two(void *buffer, size_t size,
     129    usb_transaction_outcome_t outcome, void *arg)
     130{
     131        control_transfer_info_t *ctrl_transfer = (control_transfer_info_t *) arg;
     132
     133        if (outcome != USB_OUTCOME_OK) {
     134                control_abort_prematurely(ctrl_transfer, outcome, size);
     135                free(ctrl_transfer);
     136                return;
     137        }
     138
     139        transfer_info_t *transfer  = create_transfer_info(ctrl_transfer->dev,
     140            ctrl_transfer->direction, ctrl_transfer->arg);
     141        transfer->out_callback = ctrl_transfer->out_callback;
     142        transfer->in_callback = ctrl_transfer->in_callback;
     143        transfer->reported_size = size;
     144
     145        switch (ctrl_transfer->direction) {
     146                case USB_DIRECTION_IN:
     147                        hc_add_transaction_to_device(false, ctrl_transfer->target,
     148                            USB_TRANSFER_CONTROL,
     149                            NULL, 0,
     150                            universal_callback, transfer);
     151                        break;
     152                case USB_DIRECTION_OUT:
     153                        hc_add_transaction_from_device(ctrl_transfer->target,
     154                            USB_TRANSFER_CONTROL,
     155                            NULL, 0,
     156                            universal_callback, transfer);
     157                        break;
     158                default:
     159                        assert(false && "unreachable");
     160                        break;
     161        }
     162
     163        free(ctrl_transfer);
     164}
     165
     166static void control_callback_one(void *buffer, size_t size,
     167    usb_transaction_outcome_t outcome, void *arg)
     168{
     169        control_transfer_info_t *transfer = (control_transfer_info_t *) arg;
     170
     171        if (outcome != USB_OUTCOME_OK) {
     172                control_abort_prematurely(transfer, outcome, size);
     173                free(transfer);
     174                return;
     175        }
     176
     177        switch (transfer->direction) {
     178                case USB_DIRECTION_IN:
     179                        hc_add_transaction_from_device(transfer->target,
     180                            USB_TRANSFER_CONTROL,
     181                            transfer->data_buffer, transfer->data_buffer_size,
     182                            control_callback_two, transfer);
     183                        break;
     184                case USB_DIRECTION_OUT:
     185                        hc_add_transaction_to_device(false, transfer->target,
     186                            USB_TRANSFER_CONTROL,
     187                            transfer->data_buffer, transfer->data_buffer_size,
     188                            control_callback_two, transfer);
     189                        break;
     190                default:
     191                        assert(false && "unreachable");
     192                        break;
     193        }
     194}
     195
     196static control_transfer_info_t *create_control_transfer_info(device_t *dev,
     197    usb_direction_t direction, usb_target_t target,
     198    void *data_buffer, size_t data_buffer_size,
     199    void *arg)
     200{
     201        control_transfer_info_t *transfer
     202            = malloc(sizeof(control_transfer_info_t));
     203
     204        transfer->direction = direction;
     205        transfer->target = target;
     206        transfer->in_callback = NULL;
     207        transfer->out_callback = NULL;
     208        transfer->arg = arg;
     209        transfer->dev = dev;
     210        transfer->data_buffer = data_buffer;
     211        transfer->data_buffer_size = data_buffer_size;
    86212
    87213        return transfer;
    … …  
    93219    usbhc_iface_transfer_out_callback_t callback, void *arg)
    94220{
    95         dprintf(3, "transfer OUT [%d.%d (%s); %zu]",
     221        usb_log_debug2("Transfer OUT [%d.%d (%s); %zu].\n",
    96222            target.address, target.endpoint,
    97223            usb_str_transfer_type(transfer_type),
    … …  
    113239    usbhc_iface_transfer_out_callback_t callback, void *arg)
    114240{
    115         dprintf(3, "transfer SETUP [%d.%d (%s); %zu]",
     241        usb_log_debug2("Transfer SETUP [%d.%d (%s); %zu].\n",
    116242            target.address, target.endpoint,
    117243            usb_str_transfer_type(transfer_type),
    … …  
    133259    usbhc_iface_transfer_in_callback_t callback, void *arg)
    134260{
    135         dprintf(3, "transfer IN [%d.%d (%s); %zu]",
     261        usb_log_debug2("Transfer IN [%d.%d (%s); %zu].\n",
    136262            target.address, target.endpoint,
    137263            usb_str_transfer_type(transfer_type),
    … …  
    193319}
    194320
     321static int control_write(device_t *dev, usb_target_t target,
     322    void *setup_packet, size_t setup_packet_size,
     323    void *data, size_t data_size,
     324    usbhc_iface_transfer_out_callback_t callback, void *arg)
     325{
     326        control_transfer_info_t *transfer
     327            = create_control_transfer_info(dev, USB_DIRECTION_OUT, target,
     328            data, data_size, arg);
     329        transfer->out_callback = callback;
     330
     331        hc_add_transaction_to_device(true, target, USB_TRANSFER_CONTROL,
     332            setup_packet, setup_packet_size,
     333            control_callback_one, transfer);
     334
     335        return EOK;
     336}
     337
    195338static int control_read_setup(device_t *dev, usb_target_t target,
    196339    void *data, size_t size,
    … …  
    217360            NULL, 0,
    218361            callback, arg);
     362}
     363
     364static int control_read(device_t *dev, usb_target_t target,
     365    void *setup_packet, size_t setup_packet_size,
     366    void *data, size_t data_size,
     367    usbhc_iface_transfer_in_callback_t callback, void *arg)
     368{
     369        control_transfer_info_t *transfer
     370            = create_control_transfer_info(dev, USB_DIRECTION_IN, target,
     371            data, data_size, arg);
     372        transfer->in_callback = callback;
     373
     374        hc_add_transaction_to_device(true, target, USB_TRANSFER_CONTROL,
     375            setup_packet, setup_packet_size,
     376            control_callback_one, transfer);
     377
     378        return EOK;
    219379}
    220380
    … …  
    290450        .control_write_status = control_write_status,
    291451
     452        .control_write = control_write,
     453
    292454        .control_read_setup = control_read_setup,
    293455        .control_read_data = control_read_data,
    294         .control_read_status = control_read_status
     456        .control_read_status = control_read_status,
     457
     458        .control_read = control_read
    295459};
    296460

  • uspace/drv/vhc/devices.c

    rba5ab09 raec2ad4  
    196196        if (virtual_hub_device.address == transaction->target.address) {
    197197                size_t tmp;
    198                 dprintf(1, "sending `%s' transaction to hub",
     198                usb_log_debug2("Sending `%s' transaction to hub.\n",
    199199                    usbvirt_str_transaction_type(transaction->type));
    200200                switch (transaction->type) {
    … …  
    222222                                break;
    223223                }
    224                 dprintf(4, "transaction on hub processed...");
    225224                outcome = USB_OUTCOME_OK;
    226225        }

  • uspace/drv/vhc/hc.c

    rba5ab09 raec2ad4  
    9292    usb_transaction_outcome_t outcome)
    9393{
    94         dprintf(3, "transaction " TRANSACTION_FORMAT " done, outcome: %s",
     94        usb_log_debug2("Transaction " TRANSACTION_FORMAT " done: %s.\n",
    9595            TRANSACTION_PRINTF(*transaction),
    9696            usb_str_transaction_outcome(outcome));
    … …  
    108108        static unsigned int seed = 4573;
    109109       
    110         printf("%s: transaction processor ready.\n", NAME);
     110        usb_log_info("Transaction processor ready.\n");
    111111       
    112112        while (true) {
    … …  
    125125                list_remove(first_transaction_link);
    126126               
    127 
    128                 dprintf(0, "about to process " TRANSACTION_FORMAT " [%s]",
     127                usb_log_debug("Processing " TRANSACTION_FORMAT " [%s].\n",
    129128                    TRANSACTION_PRINTF(*transaction), ports);
    130129
    131                 dprintf(3, "processing transaction " TRANSACTION_FORMAT "",
    132                     TRANSACTION_PRINTF(*transaction));
    133                
    134130                usb_transaction_outcome_t outcome;
    135131                outcome = virtdev_send_to_all(transaction);
    … …  
    148144        fid_t fid = fibril_create(hc_manager_fibril, NULL);
    149145        if (fid == 0) {
    150                 printf(NAME ": failed to start HC manager fibril\n");
     146                usb_log_fatal("Failed to start HC manager fibril.\n");
    151147                return;
    152148        }
    … …  
    172168        transaction->callback = callback;
    173169        transaction->callback_arg = arg;
    174        
    175         dprintf(3, "creating transaction " TRANSACTION_FORMAT,
     170
     171        return transaction;
     172}
     173
     174static void hc_add_transaction(transaction_t *transaction)
     175{
     176        usb_log_debug("Adding transaction " TRANSACTION_FORMAT ".\n",
    176177            TRANSACTION_PRINTF(*transaction));
    177        
    178         return transaction;
     178        list_append(&transaction->link, &transaction_list);
    179179}
    180180
    … …  
    190190            target, transfer_type,
    191191            buffer, len, callback, arg);
    192         list_append(&transaction->link, &transaction_list);
     192        hc_add_transaction(transaction);
    193193}
    194194
    … …  
    203203            target, transfer_type,
    204204            buffer, len, callback, arg);
    205         list_append(&transaction->link, &transaction_list);
     205        hc_add_transaction(transaction);
    206206}
    207207

  • uspace/drv/vhc/hcd.c

    rba5ab09 raec2ad4  
    9494        virtual_hub_device_init(dev);
    9595
    96         printf("%s: virtual USB host controller ready.\n", NAME);
     96        usb_log_info("Virtual USB host controller ready (id = %zu).\n",
     97            (size_t) dev->handle);
    9798
    9899        return EOK;
    … …  
    117118        sleep(5);
    118119
    119         usb_dprintf_enable(NAME, -1);
     120        usb_log_enable(USB_LOG_LEVEL_INFO, NAME);
    120121
    121122        printf(NAME ": virtual USB host controller driver.\n");

  • uspace/drv/vhc/hub.c

    rba5ab09 raec2ad4  
    6363            = fibril_create(hub_register_in_devman_fibril, hc_dev);
    6464        if (root_hub_registration == 0) {
    65                 printf(NAME ": failed to register root hub\n");
     65                usb_log_fatal("Failed to create hub registration fibril.\n");
    6666                return;
    6767        }
    … …  
    7979        device_t *hc_dev = (device_t *) arg;
    8080
    81         int hc = usb_drv_hc_connect(hc_dev, hc_dev->handle, IPC_FLAG_BLOCKING);
    82         if (hc < 0) {
    83                 printf(NAME ": failed to register root hub\n");
    84                 return hc;
    85         }
     81        int hc;
     82        do {
     83                hc = usb_drv_hc_connect(hc_dev, hc_dev->handle,
     84                    IPC_FLAG_BLOCKING);
     85        } while (hc < 0);
    8686
    8787        usb_drv_reserve_default_address(hc);

  • uspace/drv/vhc/vhcd.h

    rba5ab09 raec2ad4  
    4545#define DEVMAP_PATH_DEV NAMESPACE "/" NAME_DEV
    4646
    47 #define dprintf(level, format, ...) \
    48         usb_dprintf(NAME, (level), format "\n", ##__VA_ARGS__)
    49 void dprintf_inval_call(int, ipc_call_t, sysarg_t);
     47//#define dprintf(level, format, ...)
     48//      usb_dprintf(NAME, (level), format "\n", ##__VA_ARGS__)
     49//void dprintf_inval_call(int, ipc_call_t, sysarg_t);
    5050
    5151#endif
Note: See TracChangeset for help on using the changeset viewer.