Changeset 9097c16a in mainline for uspace/drv


Ignore:
Timestamp:
2011-02-04T13:14:14Z (15 years ago)
Author:
Lubos Slovak <lubos.slovak@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
9e7cdf8
Parents:
11797d5 (diff), ff244e6 (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:

Merged development

Location:
uspace/drv
Files:
2 added
1 deleted
28 edited
11 moved

Legend:

Unmodified
Added
Removed

  • uspace/drv/uhci/Makefile

    r11797d5 r9097c16a  
    3434SOURCES = \
    3535        main.c \
     36        pci.c \
    3637        transfers.c
    3738

  • uspace/drv/uhci/main.c

    r11797d5 r9097c16a  
    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

    r11797d5 r9097c16a  
    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

    r11797d5 r9097c16a  
    11#
    2 # Copyright (c) 2010 Vojtech Horky
     2# Copyright (c) 2010-2011 Vojtech Horky
    33# All rights reserved.
    44#
    … …  
    3030LIBS = $(LIBDRV_PREFIX)/libdrv.a $(LIBUSB_PREFIX)/libusb.a
    3131EXTRA_CFLAGS += -I$(LIBDRV_PREFIX)/include -I$(LIBUSB_PREFIX)/include -I.
    32 BINARY = usbkbd
    33 SRV_KBD = $(USPACE_PREFIX)/srv/hid/kbd
     32BINARY = usbhid
     33
     34STOLEN_LAYOUT_SOURCES = \
     35        layout/us_qwerty.c \
     36        layout/us_dvorak.c \
     37        layout/cz.c
    3438
    3539SOURCES = \
    … …  
    3842        descdump.c \
    3943        conv.c \
    40         us_qwerty.c \
    41         us_dvorak.c \
    42         cz.c
     44        $(STOLEN_LAYOUT_SOURCES)
     45
     46EXTRA_CLEAN = $(STOLEN_LAYOUT_SOURCES)
     47
     48SRV_KBD = $(USPACE_PREFIX)/srv/hid/kbd
    4349
    4450include $(USPACE_PREFIX)/Makefile.common
    4551
    46 us_qwerty.c:
    47         ln -snf $(SRV_KBD)/layout/$@ $@
    48 
    49 us_dvorak.c:
    50         ln -snf $(SRV_KBD)/layout/$@ $@
    51 
    52 cz.c:
    53         ln -snf $(SRV_KBD)/layout/$@ $@
    54 
    55 
     52layout/%.c: $(SRV_KBD)/layout/%.c
     53        ln -sfn ../$< $@

  • uspace/drv/usbhid/conv.c

    r11797d5 r9097c16a  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
     28
     29/** @addtogroup drvusbhid
     30 * @{
     31 */
     32/** @file
     33 * USB scancode parser.
     34 */
     35
    2836#include <io/keycode.h>
    2937#include <stdint.h>
    … …  
    185193        return key;
    186194}
     195
     196/**
     197 * @}
     198 */

  • uspace/drv/usbhid/conv.h

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbhid
    3030 * @{
    3131 */
    3232/** @file
    33  * @brief USB Scancode parser.
     33 * USB scancode parser.
    3434 */
    3535
    … …  
    4040
    4141#endif
     42
     43/**
     44 * @}
     45 */

  • uspace/drv/usbhid/descdump.c

    r11797d5 r9097c16a  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
     28
     29/** @addtogroup drvusbhid
     30 * @{
     31 */
     32/** @file
     33 * Descriptor dumping.
     34 */
     35
    2836#include <usb/classes/hid.h>
    2937
    … …  
    143151        dump_buffer("", d, size);
    144152}
     153
     154/**
     155 * @}
     156 */
     157

  • uspace/drv/usbhid/descdump.h

    r11797d5 r9097c16a  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
     28
     29/** @addtogroup drvusbhid
     30 * @{
     31 */
     32/** @file
     33 * Descriptor dumping.
     34 */
     35
    2836#ifndef USBHID_DESCDUMP_H_
    2937#define USBHID_DESCDUMP_H_
    3038
    31 #include <usb/classes/hid.h>
     39#include "hid.h"
    3240
    3341void dump_standard_configuration_descriptor(
    … …  
    5058
    5159#endif /* USBHID_DESCDUMP_H_ */
     60
     61/**
     62 * @}
     63 */

  • uspace/drv/usbhid/descparser.c

    r11797d5 r9097c16a  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
     28
     29/** @addtogroup drvusbhid
     30 * @{
     31 */
     32/** @file
     33 * Descriptor parser.
     34 */
     35
    2836#include <errno.h>
    2937#include <stdint.h>
    … …  
    338346        }
    339347}
     348
     349/**
     350 * @}
     351 */

  • uspace/drv/usbhid/descparser.h

    r11797d5 r9097c16a  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
     28
     29/** @addtogroup drvusbhid
     30 * @{
     31 */
     32/** @file
     33 * Descriptor parser.
     34 */
     35
    2836#ifndef USBHID_DESCPARSER_H_
    2937#define USBHID_DESCPARSER_H_
    3038
    31 #include <usb/classes/hid.h>
     39#include "hid.h"
    3240
    3341int usbkbd_parse_descriptors(const uint8_t *data, size_t size,
    … …  
    3745
    3846#endif
     47
     48/**
     49 * @}
     50 */

  • uspace/drv/usbhid/hid.h

    r11797d5 r9097c16a  
    11/*
    2  * Copyright (c) 2010 Vojtech Horky
     2 * Copyright (c) 2011 Lubos Slovak
    33 * All rights reserved.
    44 *
    … …  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbhid
    3030 * @{
    3131 */
    3232/** @file
    33  * @brief Debugging support.
     33 * Common definitions.
    3434 */
    35 #include <stdio.h>
    36 #include <ipc/ipc.h>
    37 #include <usb/debug.h>
    3835
    39 #include "vhcd.h"
     36#ifndef USBHID_HID_H_
     37#define USBHID_HID_H_
    4038
    41 
    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 }
     39#include <usb/classes/hid.h>
     40#include <driver.h>
     41#include <usb/pipes.h>
    5242
    5343/**
    54  * @}
     44 *
    5545 */
     46typedef struct {
     47        usb_standard_interface_descriptor_t iface_desc;
     48        usb_standard_endpoint_descriptor_t *endpoints;
     49        usb_standard_hid_descriptor_t hid_desc;
     50        uint8_t *report_desc;
     51        //usb_standard_hid_class_descriptor_info_t *class_desc_info;
     52        //uint8_t **class_descs;
     53} usb_hid_iface_t;
     54
     55/**
     56 *
     57 */
     58typedef struct {
     59        usb_standard_configuration_descriptor_t config_descriptor;
     60        usb_hid_iface_t *interfaces;
     61} usb_hid_configuration_t;
     62
     63/**
     64 * @brief USB/HID keyboard device type.
     65 *
     66 * Quite dummy right now.
     67 */
     68typedef struct {
     69        device_t *device;
     70        usb_hid_configuration_t *conf;
     71        usb_address_t address;
     72        usb_hid_report_parser_t *parser;
     73
     74        usb_device_connection_t wire;
     75        usb_endpoint_pipe_t poll_pipe;
     76} usb_hid_dev_kbd_t;
     77
     78// TODO: more configurations!
     79
     80#endif

  • uspace/drv/usbhid/layout.h

    r11797d5 r9097c16a  
    11/*
     2 * Copyright (c) 2009 Jiri Svoboda
    23 * Copyright (c) 2011 Lubos Slovak
    34 * (copied from /uspace/srv/hid/kbd/include/layout.h)
    … …  
    2829 */
    2930
    30 /** @addtogroup usb
    31  * @brief
    32  * @ingroup
     31/** @addtogroup drvusbhid
    3332 * @{
    3433 */
    3534/** @file
     35 * Keyboard layout.
    3636 */
    3737

  • uspace/drv/usbhid/main.c

    r11797d5 r9097c16a  
    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
     30/** @addtogroup drvusbhid
     31 * @{
     32 */
     33/**
     34 * @file
     35 * Main routines of USB HID driver.
     36 */
     37
    2838#include <usb/usbdrv.h>
    2939#include <driver.h>
    … …  
    3343#include <io/console.h>
    3444#include <errno.h>
     45#include <str_error.h>
    3546#include <fibril.h>
    3647#include <usb/classes/hid.h>
    … …  
    3950#include <usb/descriptor.h>
    4051#include <io/console.h>
     52#include "hid.h"
    4153#include "descparser.h"
    4254#include "descdump.h"
    … …  
    4557
    4658#define BUFFER_SIZE 32
    47 #define NAME "usbkbd"
     59#define NAME "usbhid"
    4860
    4961#define GUESSED_POLL_ENDPOINT 1
    … …  
    369381        if (rc < 0) {
    370382                printf("Problem setting phone to HC.\n");
    371                 free(kbd_dev);
    372                 return NULL;
     383                goto error_leave;
    373384        }
    374385
    … …  
    376387        if (rc < 0) {
    377388                printf("Problem getting address of the device.\n");
    378                 free(kbd_dev);
    379                 return NULL;
     389                goto error_leave;
    380390        }
    381391
    … …  
    387397//      }
    388398
    389         // default endpoint
    390         kbd_dev->poll_endpoint = GUESSED_POLL_ENDPOINT;
    391        
    392399        /*
    393400         * will need all descriptors:
    … …  
    400407        usbkbd_process_descriptors(kbd_dev);
    401408
     409
     410
     411        /*
     412         * Initialize the backing connection to the host controller.
     413         */
     414        rc = usb_device_connection_initialize_from_device(&kbd_dev->wire, dev);
     415        if (rc != EOK) {
     416                printf("Problem initializing connection to device: %s.\n",
     417                    str_error(rc));
     418                goto error_leave;
     419        }
     420
     421        /*
     422         * Initialize device pipes.
     423         */
     424        rc = usb_endpoint_pipe_initialize(&kbd_dev->poll_pipe, &kbd_dev->wire,
     425            GUESSED_POLL_ENDPOINT, USB_TRANSFER_INTERRUPT, USB_DIRECTION_IN);
     426        if (rc != EOK) {
     427                printf("Failed to initialize interrupt in pipe: %s.\n",
     428                    str_error(rc));
     429                goto error_leave;
     430        }
     431
     432
    402433        return kbd_dev;
     434
     435error_leave:
     436        free(kbd_dev);
     437        return NULL;
    403438}
    404439
    … …  
    413448        //usb_hid_parse_report(kbd_dev->parser, buffer, actual_size, callbacks,
    414449        //    NULL);
    415         printf("Calling usb_hid_boot_keyboard_input_report() with size %d\n",
     450        printf("Calling usb_hid_boot_keyboard_input_report() with size %zu\n",
    416451            actual_size);
    417452        //dump_buffer("bufffer: ", buffer, actual_size);
    … …  
    425460static void usbkbd_poll_keyboard(usb_hid_dev_kbd_t *kbd_dev)
    426461{
    427         int rc;
    428         usb_handle_t handle;
     462        int rc, sess_rc;
    429463        uint8_t buffer[BUFFER_SIZE];
    430464        size_t actual_size;
    431         //usb_endpoint_t poll_endpoint = 1;
    432 
    433 //      usb_address_t my_address = usb_drv_get_my_address(dev->parent_phone,
    434 //          dev);
    435 //      if (my_address < 0) {
    436 //              return;
    437 //      }
    438 
    439         usb_target_t poll_target = {
    440                 .address = kbd_dev->address,
    441                 .endpoint = kbd_dev->poll_endpoint
    442         };
    443465
    444466        printf("Polling keyboard...\n");
    … …  
    446468        while (true) {
    447469                async_usleep(1000 * 1000 * 2);
    448                 rc = usb_drv_async_interrupt_in(kbd_dev->device->parent_phone,
    449                     poll_target, buffer, BUFFER_SIZE, &actual_size, &handle);
     470
     471                sess_rc = usb_endpoint_pipe_start_session(&kbd_dev->poll_pipe);
     472                if (sess_rc != EOK) {
     473                        printf("Failed to start a session: %s.\n",
     474                            str_error(sess_rc));
     475                        continue;
     476                }
     477
     478                rc = usb_endpoint_pipe_read(&kbd_dev->poll_pipe, buffer,
     479                    BUFFER_SIZE, &actual_size);
     480                sess_rc = usb_endpoint_pipe_end_session(&kbd_dev->poll_pipe);
    450481
    451482                if (rc != EOK) {
    452                         printf("Error in usb_drv_async_interrupt_in(): %d\n", rc);
     483                        printf("Error polling the keyboard: %s.\n",
     484                            str_error(rc));
    453485                        continue;
    454486                }
    455487
    456                 rc = usb_drv_async_wait_for(handle);
    457                 if (rc != EOK) {
    458                         printf("Error in usb_drv_async_wait_for(): %d\n", rc);
     488                if (sess_rc != EOK) {
     489                        printf("Error closing session: %s.\n",
     490                            str_error(sess_rc));
    459491                        continue;
    460492                }
    … …  
    557589        return driver_main(&kbd_driver);
    558590}
     591
     592/**
     593 * @}
     594 */

  • uspace/drv/usbhub/main.c

    r11797d5 r9097c16a  
    2727 */
    2828
     29/** @addtogroup drvusbhub
     30 * @{
     31 */
     32
    2933#include <driver.h>
    3034#include <errno.h>
    … …  
    3842
    3943usb_general_list_t usb_hub_list;
    40 futex_t usb_hub_list_lock;
     44fibril_mutex_t usb_hub_list_lock;
    4145
    4246static driver_ops_t hub_driver_ops = {
    … …  
    6064int main(int argc, char *argv[])
    6165{
    62         usb_dprintf_enable(NAME,1);
    63         futex_initialize(&usb_hub_list_lock, 0);
     66        usb_dprintf_enable(NAME, 0);
     67       
     68        fibril_mutex_initialize(&usb_hub_list_lock);
     69        fibril_mutex_lock(&usb_hub_list_lock);
    6470        usb_lst_init(&usb_hub_list);
    65         futex_up(&usb_hub_list_lock);
     71        fibril_mutex_unlock(&usb_hub_list_lock);
     72
    6673        fid_t fid = fibril_create(usb_hub_control_loop, NULL);
    6774        if (fid == 0) {
    68                 dprintf(1, "failed to start fibril for HUB devices");
    69                 //printf("%s: failed to start fibril for HUB devices\n", NAME);
     75                fprintf(stderr, NAME ": failed to start monitoring fibril," \
     76                    " driver aborting.\n");
    7077                return ENOMEM;
    7178        }
    … …  
    7481        return driver_main(&hub_driver);
    7582}
     83
     84/**
     85 * @}
     86 */
     87

  • uspace/drv/usbhub/port_status.h

    r11797d5 r9097c16a  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
     28/** @addtogroup drvusbhub
     29 * @{
     30 */
    2831
    2932#ifndef PORT_STATUS_H
    … …  
    302305#endif  /* PORT_STATUS_H */
    303306
     307/**
     308 * @}
     309 */

  • uspace/drv/usbhub/usbhub.c

    r11797d5 r9097c16a  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
    28 /** @addtogroup usb hub driver
     28/** @addtogroup drvusbhub
    2929 * @{
    3030 */
    … …  
    7676        //get some hub info
    7777        usb_address_t addr = usb_drv_get_my_address(hc, device);
    78         dprintf(1,"[usb_hub] address of newly created hub = %d", addr);
     78        dprintf(1, "address of newly created hub = %d", addr);
    7979        /*if(addr<0){
    8080                //return result;
    … …  
    100100
    101101        if (opResult != EOK) {
    102                 dprintf(1,"[usb_hub] failed when receiving hub descriptor, badcode = %d",opResult);
     102                dprintf(1, "failed when receiving hub descriptor, badcode = %d",opResult);
    103103                free(serialized_descriptor);
    104104                return result;
    … …  
    107107        descriptor = usb_deserialize_hub_desriptor(serialized_descriptor);
    108108        if(descriptor==NULL){
    109                 dprintf(1,"[usb_hub] could not deserialize descriptor ");
     109                dprintf(1, "could not deserialize descriptor ");
    110110                result->port_count = 1;///\TODO this code is only for debug!!!
    111111                return result;
    … …  
    127127        //finish
    128128
    129         dprintf(1,"[usb_hub] hub info created");
     129        dprintf(1, "hub info created");
    130130
    131131        return result;
    … …  
    134134int usb_add_hub_device(device_t *dev) {
    135135        dprintf(1, "add_hub_device(handle=%d)", (int) dev->handle);
    136         dprintf(1,"[usb_hub] hub device");
     136        dprintf(1, "hub device");
    137137
    138138        /*
    … …  
    162162        usb_standard_device_descriptor_t std_descriptor;
    163163        opResult = usb_drv_req_get_device_descriptor(hc, target.address,
    164     &std_descriptor);
     164            &std_descriptor);
    165165        if(opResult!=EOK){
    166                 dprintf(1,"[usb_hub] could not get device descriptor, %d",opResult);
     166                dprintf(1, "could not get device descriptor, %d",opResult);
    167167                return opResult;
    168168        }
    169         dprintf(1,"[usb_hub] hub has %d configurations",std_descriptor.configuration_count);
     169        dprintf(1, "hub has %d configurations",std_descriptor.configuration_count);
    170170        if(std_descriptor.configuration_count<1){
    171                 dprintf(1,"[usb_hub] THERE ARE NO CONFIGURATIONS AVAILABLE");
     171                dprintf(1, "THERE ARE NO CONFIGURATIONS AVAILABLE");
    172172                //shouldn`t I return?
    173173        }
    … …  
    178178        &config_descriptor);
    179179        if(opResult!=EOK){
    180                 dprintf(1,"[usb_hub] could not get configuration descriptor, %d",opResult);
     180                dprintf(1, "could not get configuration descriptor, %d",opResult);
    181181                return opResult;
    182182        }
    … …  
    186186
    187187        if (opResult != EOK) {
    188                 dprintf(1,"[usb_hub]something went wrong when setting hub`s configuration, %d", opResult);
     188                dprintf(1, "something went wrong when setting hub`s configuration, %d", opResult);
    189189        }
    190190
    … …  
    193193                usb_hub_set_power_port_request(&request, port);
    194194                opResult = usb_drv_sync_control_write(hc, target, &request, NULL, 0);
    195                 dprintf(1,"[usb_hub] powering port %d",port);
     195                dprintf(1, "powering port %d",port);
    196196                if (opResult != EOK) {
    197                         dprintf(1,"[usb_hub]something went wrong when setting hub`s %dth port", port);
     197                        dprintf(1, "something went wrong when setting hub`s %dth port", port);
    198198                }
    199199        }
    … …  
    203203
    204204        //add the hub to list
    205         futex_down(&usb_hub_list_lock);
     205        fibril_mutex_lock(&usb_hub_list_lock);
    206206        usb_lst_append(&usb_hub_list, hub_info);
    207         futex_up(&usb_hub_list_lock);
    208 
    209         dprintf(1,"[usb_hub] hub info added to list");
     207        fibril_mutex_unlock(&usb_hub_list_lock);
     208
     209        dprintf(1, "hub info added to list");
    210210        //(void)hub_info;
    211211        usb_hub_check_hub_changes();
    … …  
    213213       
    214214
    215         dprintf(1,"[usb_hub] hub dev added");
    216         dprintf(1,"\taddress %d, has %d ports ",
     215        dprintf(1, "hub dev added");
     216        dprintf(1, "\taddress %d, has %d ports ",
    217217                        hub_info->usb_device->address,
    218218                        hub_info->port_count);
    219         dprintf(1,"\tused configuration %d",config_descriptor.configuration_number);
     219        dprintf(1, "\tused configuration %d",config_descriptor.configuration_number);
    220220
    221221        return EOK;
    … …  
    238238inline static int usb_hub_release_default_address(int hc){
    239239        int opResult;
    240         dprintf(1,"[usb_hub] releasing default address");
     240        dprintf(1, "releasing default address");
    241241        opResult = usb_drv_release_default_address(hc);
    242242        if (opResult != EOK) {
    243                 dprintf(1,"[usb_hub] failed to release default address");
     243                dprintf(1, "failed to release default address");
    244244        }
    245245        return opResult;
    … …  
    255255        usb_device_request_setup_packet_t request;
    256256        int opResult;
    257         dprintf(1,"[usb_hub] some connection changed");
     257        dprintf(1, "some connection changed");
    258258        //get default address
    259259        opResult = usb_drv_reserve_default_address(hc);
    260260        if (opResult != EOK) {
    261                 dprintf(1,"[usb_hub] cannot assign default address, it is probably used");
     261                dprintf(1, "cannot assign default address, it is probably used");
    262262                return;
    263263        }
    … …  
    270270                        );
    271271        if (opResult != EOK) {
    272                 dprintf(1,"[usb_hub] something went wrong when reseting a port");
     272                dprintf(1, "something went wrong when reseting a port");
    273273                usb_hub_release_default_address(hc);
    274274        }
    … …  
    285285
    286286        int opResult;
    287         dprintf(1,"[usb_hub] finalizing add device");
     287        dprintf(1, "finalizing add device");
    288288        opResult = usb_hub_clear_port_feature(hc, target.address,
    289289            port, USB_HUB_FEATURE_C_PORT_RESET);
    290290        if (opResult != EOK) {
    291                 dprintf(1,"[usb_hub] failed to clear port reset feature");
     291                dprintf(1, "failed to clear port reset feature");
    292292                usb_hub_release_default_address(hc);
    293293                return;
    … …  
    297297        usb_address_t new_device_address = usb_drv_request_address(hc);
    298298        if (new_device_address < 0) {
    299                 dprintf(1,"[usb_hub] failed to get free USB address");
     299                dprintf(1, "failed to get free USB address");
    300300                opResult = new_device_address;
    301301                usb_hub_release_default_address(hc);
    302302                return;
    303303        }
    304         dprintf(1,"[usb_hub] setting new address");
     304        dprintf(1, "setting new address");
    305305        opResult = usb_drv_req_set_address(hc, USB_ADDRESS_DEFAULT,
    306306            new_device_address);
    307307
    308308        if (opResult != EOK) {
    309                 dprintf(1,"[usb_hub] could not set address for new device");
     309                dprintf(1, "could not set address for new device");
    310310                usb_hub_release_default_address(hc);
    311311                return;
    … …  
    322322            new_device_address, &child_handle);
    323323        if (opResult != EOK) {
    324                 dprintf(1,"[usb_hub] could not start driver for new device");
     324                dprintf(1, "could not start driver for new device");
    325325                return;
    326326        }
    … …  
    330330        opResult = usb_drv_bind_address(hc, new_device_address, child_handle);
    331331        if (opResult != EOK) {
    332                 dprintf(1,"[usb_hub] could not assign address of device in hcd");
    333                 return;
    334         }
    335         dprintf(1,"[usb_hub] new device address %d, handle %zu",
     332                dprintf(1, "could not assign address of device in hcd");
     333                return;
     334        }
     335        dprintf(1, "new device address %d, handle %zu",
    336336            new_device_address, child_handle);
    337337
    … …  
    358358                opResult = usb_drv_release_address(hc,hub->attached_devs[port].address);
    359359                if(opResult != EOK) {
    360                         dprintf(1,
    361                                         "[usb_hub] could not release address of removed device: %d"
    362                                         ,opResult);
     360                        dprintf(1, "could not release address of " \
     361                            "removed device: %d", opResult);
    363362                }
    364363                hub->attached_devs[port].address = 0;
    365364        }else{
    366                 dprintf(1,
    367                                 "[usb_hub] this is strange, disconnected device had no address");
     365                dprintf(1, "this is strange, disconnected device had no address");
    368366                //device was disconnected before it`s port was reset - return default address
    369367                usb_drv_release_default_address(hc);
    … …  
    379377static void usb_hub_process_interrupt(usb_hub_info_t * hub, int hc,
    380378        uint16_t port, usb_address_t address) {
    381         dprintf(1,"[usb_hub] interrupt at port %d", port);
     379        dprintf(1, "interrupt at port %d", port);
    382380        //determine type of change
    383381        usb_target_t target;
    … …  
    397395                        );
    398396        if (opResult != EOK) {
    399                 dprintf(1,"[usb_hub] ERROR: could not get port status");
     397                dprintf(1, "ERROR: could not get port status");
    400398                return;
    401399        }
    402400        if (rcvd_size != sizeof (usb_port_status_t)) {
    403                 dprintf(1,"[usb_hub] ERROR: received status has incorrect size");
     401                dprintf(1, "ERROR: received status has incorrect size");
    404402                return;
    405403        }
    … …  
    410408                // TODO: check opResult
    411409                if (usb_port_dev_connected(&status)) {
    412                         dprintf(1,"[usb_hub] some connection changed");
     410                        dprintf(1, "some connection changed");
    413411                        usb_hub_init_add_device(hc, port, target);
    414412                } else {
    … …  
    418416        //port reset
    419417        if (usb_port_reset_completed(&status)) {
    420                 dprintf(1,"[usb_hub] port reset complete");
     418                dprintf(1, "port reset complete");
    421419                if (usb_port_enabled(&status)) {
    422420                        usb_hub_finalize_add_device(hub, hc, port, target);
    423421                } else {
    424                         dprintf(1,"[usb_hub] ERROR: port reset, but port still not enabled");
     422                        dprintf(1, "ERROR: port reset, but port still not enabled");
    425423                }
    426424        }
    … …  
    431429        usb_port_set_dev_connected(&status, false);
    432430        if (status>>16) {
    433                 dprintf(1,"[usb_hub]there was some unsupported change on port %d: %X",port,status);
     431                dprintf(1, "there was some unsupported change on port %d: %X",port,status);
    434432
    435433        }
    … …  
    447445         */
    448446        usb_general_list_t * lst_item;
    449         futex_down(&usb_hub_list_lock);
     447        fibril_mutex_lock(&usb_hub_list_lock);
    450448        for (lst_item = usb_hub_list.next;
    451449                        lst_item != &usb_hub_list;
    452450                        lst_item = lst_item->next) {
    453                 futex_up(&usb_hub_list_lock);
     451                fibril_mutex_unlock(&usb_hub_list_lock);
    454452                usb_hub_info_t * hub_info = ((usb_hub_info_t*)lst_item->data);
    455453                /*
    … …  
    460458                target.address = hub_info->usb_device->address;
    461459                target.endpoint = 1;/// \TODO get from endpoint descriptor
    462                 /*dprintf(1,"[usb_hub] checking changes for hub at addr %d",
    463                     target.address);*/
     460                dprintf(1, "checking changes for hub at addr %d",
     461                    target.address);
    464462
    465463                size_t port_count = hub_info->port_count;
    … …  
    490488
    491489                if (opResult != EOK) {
    492                         dprintf(1,"[usb_hub] something went wrong while getting status of hub");
     490                        free(change_bitmap);
     491                        dprintf(1, "something went wrong while getting status of hub");
    493492                        continue;
    494493                }
    … …  
    505504
    506505                ipc_hangup(hc);
    507                 futex_down(&usb_hub_list_lock);
    508         }
    509         futex_up(&usb_hub_list_lock);
     506                fibril_mutex_lock(&usb_hub_list_lock);
     507        }
     508        fibril_mutex_unlock(&usb_hub_list_lock);
    510509}
    511510

  • uspace/drv/usbhub/usbhub.h

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbhub
    3030 * @{
    3131 */

  • uspace/drv/usbhub/usbhub_private.h

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbhub
    3030 * @{
    3131 */
    … …  
    4343#include <bool.h>
    4444#include <driver.h>
    45 #include <futex.h>
     45#include <fibril_synch.h>
    4646
    4747#include <usb/usb.h>
    … …  
    8282
    8383/** Lock for hub list*/
    84 extern futex_t usb_hub_list_lock;
     84extern fibril_mutex_t usb_hub_list_lock;
    8585
    8686

  • uspace/drv/usbhub/usblist.c

    r11797d5 r9097c16a  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
    28 /** @addtogroup usb hub driver
     28/** @addtogroup drvusbhub
    2929 * @{
    3030 */

  • uspace/drv/usbhub/usblist.h

    r11797d5 r9097c16a  
    2727 */
    2828
    29 
    30 #ifndef USBLIST_H
    31 #define USBLIST_H
    32 /** @addtogroup usb hub driver
     29/** @addtogroup drvusbhub
    3330 * @{
    3431 */
    … …  
    4037 * much simpler and more straight-forward semantics.
    4138 */
     39#ifndef USBLIST_H
     40#define USBLIST_H
    4241
    4342/**
    … …  
    7877}
    7978
    80 
     79#endif  /* USBLIST_H */
    8180/**
    8281 * @}
    8382 */
    84 
    85 
    86 
    87 #endif  /* USBLIST_H */
    88 

  • uspace/drv/usbhub/utils.c

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup libusb usb
     29/** @addtogroup drvusbhub
    3030 * @{
    3131 */

  • uspace/drv/vhc/Makefile

    r11797d5 r9097c16a  
    4444        conndev.c \
    4545        connhost.c \
    46         debug.c \
    4746        devices.c \
    4847        hc.c \

  • uspace/drv/vhc/conn.h

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */
    … …  
    5151
    5252void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *);
     53void on_client_close(device_t *);
    5354
    5455

  • uspace/drv/vhc/conndev.c

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */
    … …  
    8888                int callback = IPC_GET_ARG5(*icall);
    8989                virtdev_connection_t *dev
    90                     = virtdev_add_device(callback);
     90                    = virtdev_add_device(callback, (sysarg_t)fibril_get_id());
    9191                if (!dev) {
    9292                        ipc_answer_0(icallid, EEXISTS);
    … …  
    9999                int rc = get_device_name(callback, devname, DEVICE_NAME_MAXLENGTH);
    100100
    101                 dprintf(0, "virtual device connected (name: %s)",
    102                     rc == EOK ? devname : "<unknown>");
    103 
    104                 /* FIXME: destroy the device when the client disconnects. */
     101                usb_log_info("New virtual device `%s' (id = %x).\n",
     102                    rc == EOK ? devname : "<unknown>", dev->id);
    105103
    106104                return;
    … …  
    110108}
    111109
     110/** Callback for DDF when client disconnects.
     111 *
     112 * @param d Device the client was connected to.
     113 */
     114void on_client_close(device_t *d)
     115{
     116        /*
     117         * Maybe a virtual device is being unplugged.
     118         */
     119        virtdev_connection_t *dev = virtdev_find((sysarg_t)fibril_get_id());
     120        if (dev == NULL) {
     121                return;
     122        }
     123
     124        usb_log_info("Virtual device disconnected (id = %x).\n", dev->id);
     125        virtdev_destroy_device(dev);
     126}
     127
    112128
    113129/**

  • uspace/drv/vhc/connhost.c

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */
    … …  
    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

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */
    … …  
    5858/** Create virtual device.
    5959 *
    60  * @param address USB address.
    6160 * @param phone Callback phone.
     61 * @param id Device id.
    6262 * @return New device.
    63  * @retval NULL Out of memory or address already occupied.
    64  */
    65 virtdev_connection_t *virtdev_add_device(int phone)
     63 * @retval NULL Out of memory.
     64 */
     65virtdev_connection_t *virtdev_add_device(int phone, sysarg_t id)
    6666{
    6767        virtdev_connection_t *dev = (virtdev_connection_t *)
    6868            malloc(sizeof(virtdev_connection_t));
     69        if (dev == NULL) {
     70                return NULL;
     71        }
     72
    6973        dev->phone = phone;
     74        dev->id = id;
    7075        list_append(&dev->link, &devices);
    7176       
    … …  
    7378       
    7479        return dev;
     80}
     81
     82/** Find virtual device by id.
     83 *
     84 * @param id Device id.
     85 * @return Device with given id.
     86 * @retval NULL No such device.
     87 */
     88virtdev_connection_t *virtdev_find(sysarg_t id)
     89{
     90        link_t *pos;
     91        list_foreach(pos, &devices) {
     92                virtdev_connection_t *dev
     93                    = list_get_instance(pos, virtdev_connection_t, link);
     94                if (dev->id == id) {
     95                        return dev;
     96                }
     97        }
     98
     99        return NULL;
    75100}
    76101
    … …  
    90115usb_transaction_outcome_t virtdev_send_to_all(transaction_t *transaction)
    91116{
     117        /* For easier debugging. */
     118        switch (transaction->type) {
     119                case USBVIRT_TRANSACTION_SETUP:
     120                case USBVIRT_TRANSACTION_OUT:
     121                        transaction->actual_len = transaction->len;
     122                        break;
     123                case USBVIRT_TRANSACTION_IN:
     124                        transaction->actual_len = 0;
     125                        break;
     126                default:
     127                        assert(false && "unreachable branch in switch()");
     128        }
     129        usb_transaction_outcome_t outcome = USB_OUTCOME_BABBLE;
     130
    92131        link_t *pos;
    93132        list_foreach(pos, &devices) {
    … …  
    141180                        rc = (int)answer_rc;
    142181                }
     182
     183                /*
     184                 * If at least one device was able to accept this
     185                 * transaction and process it, we can announce success.
     186                 */
     187                if (rc == EOK) {
     188                        outcome = USB_OUTCOME_OK;
     189                }
    143190        }
    144191       
    … …  
    149196        if (virtual_hub_device.address == transaction->target.address) {
    150197                size_t tmp;
    151                 dprintf(1, "sending `%s' transaction to hub",
     198                usb_log_debug2("Sending `%s' transaction to hub.\n",
    152199                    usbvirt_str_transaction_type(transaction->type));
    153200                switch (transaction->type) {
    … …  
    165212                                    transaction->buffer, transaction->len,
    166213                                    &tmp);
    167                                 if (tmp < transaction->len) {
    168                                         transaction->len = tmp;
    169                                 }
     214                                transaction->actual_len = tmp;
    170215                                break;
    171216                               
    … …  
    177222                                break;
    178223                }
    179                 dprintf(4, "transaction on hub processed...");
     224                outcome = USB_OUTCOME_OK;
    180225        }
    181226       
    … …  
    184229         * real-life image.
    185230         */
    186         return USB_OUTCOME_OK;
     231        return outcome;
    187232}
    188233

  • uspace/drv/vhc/devices.h

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */
    … …  
    4545        /** Phone used when sending data to device. */
    4646        int phone;
     47        /** Unique identification. */
     48        sysarg_t id;
    4749        /** Linked-list handle. */
    4850        link_t link;
    4951} virtdev_connection_t;
    5052
    51 virtdev_connection_t *virtdev_add_device(int);
    52 virtdev_connection_t *virtdev_get_mine(void);
     53virtdev_connection_t *virtdev_add_device(int, sysarg_t);
     54virtdev_connection_t *virtdev_find(sysarg_t);
    5355void virtdev_destroy_device(virtdev_connection_t *);
    5456usb_transaction_outcome_t virtdev_send_to_all(transaction_t *);

  • uspace/drv/vhc/hc.c

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */
    … …  
    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/hc.h

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */

  • uspace/drv/vhc/hcd.c

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */
    … …  
    6969        .interfaces[USBHC_DEV_IFACE] = &vhc_iface,
    7070        .interfaces[USB_DEV_IFACE] = &hc_usb_iface,
     71        .close = on_client_close,
    7172        .default_handler = default_connection_handler
    7273};
    … …  
    9394        virtual_hub_device_init(dev);
    9495
    95         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);
    9698
    9799        return EOK;
    … …  
    116118        sleep(5);
    117119
    118         usb_dprintf_enable(NAME, -1);
     120        usb_log_enable(USB_LOG_LEVEL_INFO, NAME);
    119121
    120122        printf(NAME ": virtual USB host controller driver.\n");

  • uspace/drv/vhc/hub.c

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */
    … …  
    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/hub.h

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */

  • uspace/drv/vhc/hub/hub.c

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */
    … …  
    155155}
    156156
     157/** Disconnects a device from a hub.
     158 *
     159 * @param hub Hub the device was connected to.
     160 * @param device Device to be disconnected.
     161 * @return Error code.
     162 */
     163int hub_disconnect_device(hub_t *hub, void *device)
     164{
     165        size_t index = hub_find_device(hub, device);
     166        if (index == (size_t) -1) {
     167                return ENOENT;
     168        }
     169
     170        hub_port_t *port = &hub->ports[index];
     171
     172        port->connected_device = NULL;
     173        port->state = HUB_PORT_STATE_DISCONNECTED;
     174        set_port_status_change(port, HUB_STATUS_C_PORT_CONNECTION);
     175
     176        return EOK;
     177}
     178
    157179/** Find port device is connected to.
    158180 *
    … …  
    173195        }
    174196
    175         return 0;
     197        return -1;
    176198}
    177199

  • uspace/drv/vhc/hub/hub.h

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */
    … …  
    3838#include <fibril_synch.h>
    3939
     40#ifndef HUB_PORT_COUNT
    4041#define HUB_PORT_COUNT 2
     42#endif
    4143#define BITS2BYTES(bits) (bits ? ((((bits)-1)>>3)+1) : 0)
    4244
    … …  
    9496void hub_init(hub_t *);
    9597size_t hub_connect_device(hub_t *, void *);
     98int hub_disconnect_device(hub_t *, void *);
    9699size_t hub_find_device(hub_t *, void *);
    97100void hub_acquire(hub_t *);

  • uspace/drv/vhc/hub/virthub.c

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */
    … …  
    164164        dev->device_data = hub;
    165165
    166         usbvirt_connect_local(dev);
    167 
    168         return EOK;
     166        int rc;
     167#ifdef STANDALONE_HUB
     168        dev->name = "hub";
     169        rc = usbvirt_connect(dev);
     170#else
     171        rc = usbvirt_connect_local(dev);
     172#endif
     173
     174        return rc;
    169175}
    170176
    … …  
    203209
    204210        hub_acquire(hub);
    205         /* TODO: implement. */
     211        hub_disconnect_device(hub, conn);
    206212        hub_release(hub);
    207213

  • uspace/drv/vhc/hub/virthub.h

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */
    … …  
    3737
    3838#include <usbvirt/device.h>
     39#include "hub.h"
     40
     41#ifdef STANDALONE_HUB
     42#define virtdev_connection_t int
     43#else
    3944#include "../devices.h"
    40 #include "hub.h"
     45#endif
    4146
    4247/** Endpoint number for status change pipe. */

  • uspace/drv/vhc/hub/virthubops.c

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */

  • uspace/drv/vhc/vhcd.h

    r11797d5 r9097c16a  
    2727 */
    2828
    29 /** @addtogroup usb
     29/** @addtogroup drvusbvhc
    3030 * @{
    3131 */
    … …  
    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.