Changes in / [7ab7c7f6:5d07f54] in mainline


Ignore:
Files:
12 added
5 deleted
27 edited

Legend:

Unmodified
Added
Removed

  • boot/Makefile.common

    r7ab7c7f6 r5d07f54  
    140140        $(USPACE_PATH)/app/stats/stats \
    141141        $(USPACE_PATH)/app/sysinfo/sysinfo \
     142        $(USPACE_PATH)/app/tasks/tasks \
    142143        $(USPACE_PATH)/app/top/top \
    143144        $(USPACE_PATH)/app/usbinfo/usbinfo \
     145        $(USPACE_PATH)/app/virtusbkbd/vuk \
    144146        $(USPACE_PATH)/app/vuhid/vuh \
    145147        $(USPACE_PATH)/app/websrv/websrv

  • uspace/Makefile

    r7ab7c7f6 r5d07f54  
    5151        app/top \
    5252        app/usbinfo \
     53        app/virtusbkbd \
    5354        app/vuhid \
    5455        app/netecho \

  • uspace/app/vuhid/device.c

    r7ab7c7f6 r5d07f54  
    7777{
    7878        vuhid_interface_t *iface = arg;
    79         vuhid_data_t *hid_data = iface->vuhid_data;
    8079
    8180        if (iface->live != NULL) {
    8281                iface->live(iface);
    8382        }
    84 
    85         fibril_mutex_lock(&hid_data->iface_count_mutex);
    86         hid_data->iface_died_count++;
    87         fibril_condvar_broadcast(&hid_data->iface_count_cv);
    88         fibril_mutex_unlock(&hid_data->iface_count_mutex);
    8983
    9084        return EOK;
    … …  
    116110        if ((iface->in_data_size == 0) && (iface->out_data_size == 0)) {
    117111                return EEMPTY;
    118         }
    119 
    120         // FIXME - we shall set vuhid_data to NULL in the main() rather
    121         // than to depend on individual interfaces
    122         /* Already used interface. */
    123         if (iface->vuhid_data != NULL) {
    124                 return EEXISTS;
    125112        }
    126113
    … …  
    265252
    266253        /* Launch the "life" fibril. */
    267         iface->vuhid_data = hid_data;
    268254        fid_t life_fibril = fibril_create(interface_life_fibril, iface);
    269255        if (life_fibril == 0) {
    … …  
    324310            += total_descr_size;
    325311
    326         hid_data->iface_count++;
    327312        fibril_add_ready(life_fibril);
    328313
    … …  
    346331}
    347332
    348 void wait_for_interfaces_death(usbvirt_device_t *dev)
    349 {
    350         vuhid_data_t *hid_data = dev->device_data;
    351 
    352         fibril_mutex_lock(&hid_data->iface_count_mutex);
    353         while (hid_data->iface_died_count < hid_data->iface_count) {
    354                 fibril_condvar_wait(&hid_data->iface_count_cv,
    355                     &hid_data->iface_count_mutex);
    356         }
    357         fibril_mutex_unlock(&hid_data->iface_count_mutex);
    358 }
    359333
    360334/** @}

  • uspace/app/vuhid/hids/bootkbd.c

    r7ab7c7f6 r5d07f54  
    3939#include <usb/classes/hidut.h>
    4040
    41 #include "../report.h"
     41#include "../../virtusbkbd/report.h"
    4242
    4343uint8_t report_descriptor[] = {
    … …  
    169169        .on_data_out = on_data_out,
    170170
    171         .live = live,
    172 
    173         .vuhid_data = NULL
     171        .live = live
    174172};
    175173

  • uspace/app/vuhid/main.c

    r7ab7c7f6 r5d07f54  
    132132        .in_endpoint_first_free = 1,
    133133        .out_endpoints_mapping = { NULL },
    134         .out_endpoint_first_free = 1,
    135 
    136         .iface_count = 0,
    137         .iface_died_count = 0
    138         // mutex and CV must be initialized elsewhere
     134        .out_endpoint_first_free = 1
    139135};
    140 
    141136
    142137/** Keyboard device.
    … …  
    156151
    157152        usb_log_enable(USB_LOG_LEVEL_DEBUG2, "vusbhid");
    158 
    159         fibril_mutex_initialize(&vuhid_data.iface_count_mutex);
    160         fibril_condvar_initialize(&vuhid_data.iface_count_cv);
    161153
    162154        /* Determine which interfaces to initialize. */
    … …  
    190182        printf("Connected to VHCD...\n");
    191183
    192         wait_for_interfaces_death(&hid_dev);
     184        while (true) {
     185                async_usleep(10 * 1000 * 1000);
     186        }
    193187       
    194188        printf("Terminating...\n");
    195189       
    196         usbvirt_device_unplug(&hid_dev);
    197 
    198190        return 0;
    199191}

  • uspace/app/vuhid/virthid.h

    r7ab7c7f6 r5d07f54  
    3838#include <usb/usb.h>
    3939#include <usbvirt/device.h>
    40 #include <fibril_synch.h>
    4140
    4241#define VUHID_ENDPOINT_MAX USB11_ENDPOINT_MAX
    … …  
    4443
    4544typedef struct vuhid_interface vuhid_interface_t;
    46 
    47 typedef struct {
    48         vuhid_interface_t *in_endpoints_mapping[VUHID_ENDPOINT_MAX];
    49         size_t in_endpoint_first_free;
    50         vuhid_interface_t *out_endpoints_mapping[VUHID_ENDPOINT_MAX];
    51         size_t out_endpoint_first_free;
    52         vuhid_interface_t *interface_mapping[VUHID_INTERFACE_MAX];
    53 
    54         fibril_mutex_t iface_count_mutex;
    55         fibril_condvar_t iface_count_cv;
    56         size_t iface_count;
    57         size_t iface_died_count;
    58 } vuhid_data_t;
    5945
    6046struct vuhid_interface {
    … …  
    7763
    7864        void *interface_data;
     65};
    7966
    80         vuhid_data_t *vuhid_data;
    81 };
     67typedef struct {
     68        vuhid_interface_t *in_endpoints_mapping[VUHID_ENDPOINT_MAX];
     69        size_t in_endpoint_first_free;
     70        vuhid_interface_t *out_endpoints_mapping[VUHID_ENDPOINT_MAX];
     71        size_t out_endpoint_first_free;
     72        vuhid_interface_t *interface_mapping[VUHID_INTERFACE_MAX];
     73} vuhid_data_t;
    8274
    8375typedef struct {
    … …  
    9284
    9385int add_interface_by_id(vuhid_interface_t **, const char *, usbvirt_device_t *);
    94 void wait_for_interfaces_death(usbvirt_device_t *);
    9586
    9687#endif

  • uspace/drv/usbhid/generic/hiddev.c

    r7ab7c7f6 r5d07f54  
    3939#include <errno.h>
    4040#include <str_error.h>
    41 #include <bool.h>
    4241
    4342#include <usbhid_iface.h>
    … …  
    6564    size_t size, size_t *act_size, unsigned int flags);
    6665
    67 static int usb_generic_hid_client_connected(ddf_fun_t *fun);
    68 
    6966/*----------------------------------------------------------------------------*/
    7067
    … …  
    7572
    7673static ddf_dev_ops_t usb_generic_hid_ops = {
    77         .interfaces[USBHID_DEV_IFACE] = &usb_generic_iface,
    78         .open = usb_generic_hid_client_connected
     74        .interfaces[USBHID_DEV_IFACE] = &usb_generic_iface
    7975};
    8076
    … …  
    108104       
    109105        /*! @todo This should probably be atomic. */
    110         if (usb_hid_report_ready()) {
    111                 memcpy(buffer, hid_dev->input_report,
    112                     hid_dev->input_report_size);
    113                 *act_size = hid_dev->input_report_size;
    114                 usb_hid_report_received();
    115         }
     106        memcpy(buffer, hid_dev->input_report, hid_dev->input_report_size);
     107        *act_size = hid_dev->input_report_size;
    116108       
    117109        // clear the buffer so that it will not be received twice
    118         //memset(hid_dev->input_report, 0, hid_dev->input_report_size);
     110        memset(hid_dev->input_report, 0, hid_dev->input_report_size);
    119111       
    120         // note that we already received this report
    121 //      report_received = true;
    122        
    123         return EOK;
    124 }
    125 
    126 /*----------------------------------------------------------------------------*/
    127 
    128 static int usb_generic_hid_client_connected(ddf_fun_t *fun)
    129 {
    130         usb_hid_report_received();
    131112        return EOK;
    132113}

  • uspace/drv/usbhid/kbd/kbddev.c

    r7ab7c7f6 r5d07f54  
    255255       
    256256        if (hid_dev == NULL || hid_dev->data == NULL) {
    257                 usb_log_debug("default_connection_handler: "
    258                     "Missing parameter.\n");
    259257                async_answer_0(icallid, EINVAL);
    260258                return;
    … …  
    269267
    270268                if (kbd_dev->console_phone != -1) {
    271                         usb_log_debug("default_connection_handler: "
    272                             "console phone already set\n");
    273269                        async_answer_0(icallid, ELIMIT);
    274270                        return;
    … …  
    276272
    277273                kbd_dev->console_phone = callback;
    278                
    279                 usb_log_debug("default_connection_handler: OK\n");
    280274                async_answer_0(icallid, EOK);
    281275                return;
    282276        }
    283277       
    284         usb_log_debug("default_connection_handler: Wrong function.\n");
    285278        async_answer_0(icallid, EINVAL);
    286279}
    … …  
    562555                        usb_log_debug2("Key pressed: %d (keycode: %d)\n", key,
    563556                            kbd_dev->keys[i]);
     557                        usb_kbd_push_ev(hid_dev, kbd_dev, KEY_PRESS, key);
    564558                        if (!usb_kbd_is_lock(key)) {
    565559                                usb_kbd_repeat_start(kbd_dev, key);
    566560                        }
    567                         usb_kbd_push_ev(hid_dev, kbd_dev, KEY_PRESS, key);
    568561                } else {
    569562                        // found, nothing happens

  • uspace/drv/usbhid/mouse/mousedev.c

    r7ab7c7f6 r5d07f54  
    4343#include <str_error.h>
    4444#include <ipc/mouse.h>
    45 #include <io/console.h>
    46 
    47 #include <ipc/kbd.h>
    48 #include <io/keycode.h>
    4945
    5046#include "mousedev.h"
    … …  
    6561
    6662const char *HID_MOUSE_FUN_NAME = "mouse";
    67 const char *HID_MOUSE_WHEEL_FUN_NAME = "mouse-wheel";
    6863const char *HID_MOUSE_CLASS_NAME = "mouse";
    69 const char *HID_MOUSE_WHEEL_CLASS_NAME = "keyboard";
    7064
    7165/** Default idle rate for mouses. */
    … …  
    125119       
    126120        if (hid_dev == NULL || hid_dev->data == NULL) {
    127                 usb_log_debug("default_connection_handler: Missing "
    128                     "parameters.\n");
    129121                async_answer_0(icallid, EINVAL);
    130122                return;
    … …  
    135127        usb_mouse_t *mouse_dev = (usb_mouse_t *)hid_dev->data;
    136128       
    137         int *phone = (str_cmp(fun->name, HID_MOUSE_FUN_NAME) == 0)
    138                      ? &mouse_dev->mouse_phone : &mouse_dev->wheel_phone;
    139        
    140129        if (method == IPC_M_CONNECT_TO_ME) {
    141130                int callback = IPC_GET_ARG5(*icall);
    142131
    143                 if (*phone != -1) {
    144                         usb_log_debug("default_connection_handler: Console "
    145                             "phone to mouse already set.\n");
     132                if (mouse_dev->console_phone != -1) {
    146133                        async_answer_0(icallid, ELIMIT);
    147                         //async_answer_0(icallid, EOK);
    148134                        return;
    149135                }
    150136
    151                 *phone = callback;
     137                mouse_dev->console_phone = callback;
    152138                usb_log_debug("Console phone to mouse set ok (%d).\n", callback);
    153139                async_answer_0(icallid, EOK);
    … …  
    155141        }
    156142
    157         usb_log_debug("default_connection_handler: Invalid function.\n");
    158143        async_answer_0(icallid, EINVAL);
    159144}
    … …  
    167152                return NULL;
    168153        }
    169         mouse->mouse_phone = -1;
    170         mouse->wheel_phone = -1;
     154        mouse->console_phone = -1;
    171155       
    172156        return mouse;
    … …  
    180164       
    181165        // hangup phone to the console
    182         if ((*mouse_dev)->mouse_phone >= 0) {
    183                 async_hangup((*mouse_dev)->mouse_phone);
    184         }
    185        
    186         if ((*mouse_dev)->wheel_phone >= 0) {
    187                 async_hangup((*mouse_dev)->wheel_phone);
     166        if ((*mouse_dev)->console_phone >= 0) {
     167                async_hangup((*mouse_dev)->console_phone);
    188168        }
    189169       
    … …  
    194174/*----------------------------------------------------------------------------*/
    195175
    196 static void usb_mouse_send_wheel(const usb_mouse_t *mouse_dev, int wheel)
    197 {
    198         console_event_t ev;
    199        
    200         ev.type = KEY_PRESS;
    201         ev.key = (wheel > 0) ? KC_UP : (wheel < 0) ? KC_DOWN : 0;
    202         ev.mods = 0;
    203         ev.c = 0;
    204 
    205         if (mouse_dev->wheel_phone < 0) {
    206                 usb_log_warning(
    207                     "Connection to console not ready, key discarded.\n");
    208                 return;
    209         }
    210        
    211         int count = (wheel < 0) ? -wheel : wheel;
    212         int i;
    213        
    214         for (i = 0; i < count * 3; ++i) {
    215                 usb_log_debug2("Sending key %d to the console\n", ev.key);
    216                 async_msg_4(mouse_dev->wheel_phone, KBD_EVENT, ev.type,
    217                     ev.key, ev.mods, ev.c);
    218                 // send key release right away
    219                 async_msg_4(mouse_dev->wheel_phone, KBD_EVENT, KEY_RELEASE,
    220                     ev.key, ev.mods, ev.c);
    221         }
    222 }
    223 
    224 /*----------------------------------------------------------------------------*/
    225 
    226 static bool usb_mouse_process_report(usb_hid_dev_t *hid_dev, uint8_t *buffer,
    227     size_t buffer_size)
     176static bool usb_mouse_process_boot_report(usb_hid_dev_t *hid_dev,
     177    uint8_t *buffer, size_t buffer_size)
    228178{
    229179        usb_mouse_t *mouse_dev = (usb_mouse_t *)hid_dev->data;
    … …  
    232182            usb_debug_str_buffer(buffer, buffer_size, 0));
    233183       
    234         if (mouse_dev->mouse_phone < 0) {
     184        if (mouse_dev->console_phone < 0) {
    235185                usb_log_error(NAME " No console phone.\n");
    236186                return false;   // ??
    … …  
    302252       
    303253        if ((shift_x != 0) || (shift_y != 0)) {
    304                 async_req_2_0(mouse_dev->mouse_phone,
     254                async_req_2_0(mouse_dev->console_phone,
    305255                    MEVENT_MOVE, shift_x, shift_y);
    306256        }
    307        
    308         /*
    309          * Wheel
    310          */
    311         int wheel = 0;
    312        
    313         path = usb_hid_report_path();
    314         usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_GENERIC_DESKTOP,
    315             USB_HIDUT_USAGE_GENERIC_DESKTOP_WHEEL);
    316 
    317         usb_hid_report_path_set_report_id(path, report_id);
    318        
    319         field = usb_hid_report_get_sibling(
    320             hid_dev->report, NULL, path, USB_HID_PATH_COMPARE_END,
    321             USB_HID_REPORT_TYPE_INPUT);
    322 
    323         if (field != NULL) {
    324                 usb_log_debug(NAME " VALUE(%X) USAGE(%X)\n", field->value,
    325                     field->usage);
    326                 wheel = field->value;
    327         }
    328 
    329         usb_hid_report_path_free(path);
    330        
    331         // send arrow up for positive direction and arrow down for negative
    332         // direction; three arrows for difference of 1
    333         usb_mouse_send_wheel(mouse_dev, wheel);
    334        
    335257       
    336258        /*
    … …  
    352274                if (mouse_dev->buttons[field->usage - field->usage_minimum] == 0
    353275                    && field->value != 0) {
    354                         async_req_2_0(mouse_dev->mouse_phone,
     276                        async_req_2_0(mouse_dev->console_phone,
    355277                            MEVENT_BUTTON, field->usage, 1);
    356278                        mouse_dev->buttons[field->usage - field->usage_minimum]
    … …  
    359281                    mouse_dev->buttons[field->usage - field->usage_minimum] != 0
    360282                    && field->value == 0) {
    361                        async_req_2_0(mouse_dev->mouse_phone,
     283                       async_req_2_0(mouse_dev->console_phone,
    362284                           MEVENT_BUTTON, field->usage, 0);
    363285                       mouse_dev->buttons[field->usage - field->usage_minimum]
    … …  
    415337        }
    416338       
    417         /*
    418          * Special function for acting as keyboard (wheel)
    419          */
    420         usb_log_debug("Creating DDF function %s...\n",
    421                       HID_MOUSE_WHEEL_FUN_NAME);
    422         fun = ddf_fun_create(hid_dev->usb_dev->ddf_dev, fun_exposed,
    423             HID_MOUSE_WHEEL_FUN_NAME);
    424         if (fun == NULL) {
    425                 usb_log_error("Could not create DDF function node.\n");
    426                 return ENOMEM;
    427         }
    428        
    429         /*
    430          * Store the initialized HID device and HID ops
    431          * to the DDF function.
    432          */
    433         fun->ops = &hid_dev->ops;
    434         fun->driver_data = hid_dev;   // TODO: maybe change to hid_dev->data
    435 
    436         rc = ddf_fun_bind(fun);
    437         if (rc != EOK) {
    438                 usb_log_error("Could not bind DDF function: %s.\n",
    439                     str_error(rc));
    440                 ddf_fun_destroy(fun);
    441                 return rc;
    442         }
    443        
    444         usb_log_debug("Adding DDF function to class %s...\n",
    445             HID_MOUSE_WHEEL_CLASS_NAME);
    446         rc = ddf_fun_add_to_class(fun, HID_MOUSE_WHEEL_CLASS_NAME);
    447         if (rc != EOK) {
    448                 usb_log_error(
    449                     "Could not add DDF function to class %s: %s.\n",
    450                     HID_MOUSE_WHEEL_CLASS_NAME, str_error(rc));
    451                 ddf_fun_destroy(fun);
    452                 return rc;
    453         }
    454        
    455339        return EOK;
    456340}
    … …  
    523407        }
    524408       
    525         return usb_mouse_process_report(hid_dev, buffer, buffer_size);
     409        return usb_mouse_process_boot_report(hid_dev, buffer, buffer_size);
    526410}
    527411

  • uspace/drv/usbhid/mouse/mousedev.h

    r7ab7c7f6 r5d07f54  
    4848        //suseconds_t poll_interval_us;
    4949        /** IPC phone to console (consumer). */
    50         int mouse_phone;
    51         int wheel_phone;
     50        int console_phone;
    5251       
    5352        int32_t *buttons;

  • uspace/drv/usbhid/subdrivers.c

    r7ab7c7f6 r5d07f54  
    3636#include "subdrivers.h"
    3737#include "usb/classes/hidut.h"
    38 #include "usb/classes/hidpath.h"
    3938
    4039#include "lgtch-ultrax/lgtch-ultrax.h"
    41 #include "mouse/mousedev.h"
    4240
    4341static usb_hid_subdriver_usage_t path_kbd[] = {
    4442        {USB_HIDUT_PAGE_KEYBOARD, 0},
    45         {0, 0}
    46 };
    47 
    48 static usb_hid_subdriver_usage_t path_mouse2[] = {
    49         {USB_HIDUT_PAGE_GENERIC_DESKTOP, USB_HIDUT_USAGE_GENERIC_DESKTOP_X},
    5043        {0, 0}
    5144};
    … …  
    8679                }
    8780        },
    88         {
    89                 path_mouse2,
    90                 -1,
    91                 USB_HID_PATH_COMPARE_END
    92                 | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
    93                 -1,
    94                 -1,
    95                 {
    96                         .init = usb_mouse_init,
    97                         .deinit = usb_mouse_deinit,
    98                         .poll = usb_mouse_polling_callback,
    99                         .poll_end = NULL
    100                 }
    101         },
    10281        {NULL, -1, 0, -1, -1, {NULL, NULL, NULL, NULL}}
    10382};

  • uspace/drv/usbhid/usbhid.c

    r7ab7c7f6 r5d07f54  
    6363static const int USB_HID_MAX_SUBDRIVERS = 10;
    6464
    65 static fibril_local bool report_received;
    66 
    6765/*----------------------------------------------------------------------------*/
    6866
    … …  
    414412        }
    415413       
    416         if (fallback) {
     414        // TODO: remove the mouse hack
     415        if (hid_dev->poll_pipe_index == USB_HID_MOUSE_POLL_EP_NO ||
     416            fallback) {
    417417                // fall back to boot protocol
    418418                switch (hid_dev->poll_pipe_index) {
    … …  
    509509                                free(input_old);
    510510                        }
    511                         usb_hid_new_report();
    512511                }
    513512        }
    … …  
    590589/*----------------------------------------------------------------------------*/
    591590
    592 void usb_hid_new_report(void)
    593 {
    594         report_received = false;
    595 }
    596 
    597 /*----------------------------------------------------------------------------*/
    598 
    599 void usb_hid_report_received(void)
    600 {
    601         report_received = true;
    602 }
    603 
    604 /*----------------------------------------------------------------------------*/
    605 
    606 bool usb_hid_report_ready(void)
    607 {
    608         return !report_received;
    609 }
    610 
    611 /*----------------------------------------------------------------------------*/
    612 
    613591void usb_hid_free(usb_hid_dev_t **hid_dev)
    614592{

  • uspace/drv/usbhid/usbhid.h

    r7ab7c7f6 r5d07f54  
    4444#include <usb/devdrv.h>
    4545#include <usb/classes/hid.h>
    46 #include <bool.h>
    4746
    4847struct usb_hid_dev;
    … …  
    129128//const char *usb_hid_get_class_name(const usb_hid_dev_t *hid_dev);
    130129
    131 void usb_hid_new_report(void);
    132 
    133 void usb_hid_report_received(void);
    134 
    135 bool usb_hid_report_ready(void);
    136 
    137130void usb_hid_free(usb_hid_dev_t **hid_dev);
    138131

  • uspace/drv/vhc/transfer.c

    r7ab7c7f6 r5d07f54  
    135135                if (transfer->direction == USB_DIRECTION_IN) {
    136136                        rc = usbvirt_ipc_send_control_read(phone,
     137                            transfer->endpoint,
    137138                            transfer->setup_buffer, transfer->setup_buffer_size,
    138139                            transfer->data_buffer, transfer->data_buffer_size,
    … …  
    141142                        assert(transfer->direction == USB_DIRECTION_OUT);
    142143                        rc = usbvirt_ipc_send_control_write(phone,
     144                            transfer->endpoint,
    143145                            transfer->setup_buffer, transfer->setup_buffer_size,
    144146                            transfer->data_buffer, transfer->data_buffer_size);

  • uspace/lib/usb/include/usb/classes/hiddescriptor.h

    r7ab7c7f6 r5d07f54  
    7878uint32_t usb_hid_report_tag_data_uint32(const uint8_t *data, size_t size);
    7979
    80 usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t *report, usb_hid_report_path_t *cmp_path);
    8180#endif
    8281/**

  • uspace/lib/usb/include/usb/classes/hidpath.h

    r7ab7c7f6 r5d07f54  
    4343 * Description of path of usage pages and usages in report descriptor
    4444 */
    45 /** Wanted usage path must be exactly the same as the searched one */
    46 #define USB_HID_PATH_COMPARE_STRICT             0
    47 /** Wanted usage path must be the suffix in the searched one */
    48 #define USB_HID_PATH_COMPARE_END                1
    49 /** */
    50 #define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY    2
    51 /** Searched usage page must be prefix of the other one */
    52 #define USB_HID_PATH_COMPARE_BEGIN              4
    53 /** Searched couple of usage page and usage can be anywhere in usage path */
    54 #define USB_HID_PATH_COMPARE_ANYWHERE           8
     45#define USB_HID_PATH_COMPARE_STRICT                             0
     46#define USB_HID_PATH_COMPARE_END                                1
     47#define USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY    4
     48#define USB_HID_PATH_COMPARE_COLLECTION_ONLY    2 /* porovnava jenom cestu z Kolekci */
    5549
    5650

  • uspace/lib/usb/include/usb/classes/hidtypes.h

    r7ab7c7f6 r5d07f54  
    165165        /** */ 
    166166        link_t link;
    167 
    168         int in_delimiter;
    169167} usb_hid_report_item_t;
    170168

  • uspace/lib/usb/src/hiddescriptor.c

    r7ab7c7f6 r5d07f54  
    4141#include <assert.h>
    4242
    43 
    44 #define OUTSIDE_DELIMITER_SET   0
    45 #define START_DELIMITER_SET     1
    46 #define INSIDE_DELIMITER_SET    2
    47        
    4843/** The new report item flag. Used to determine when the item is completly
    4944 * configured and should be added to the report structure
    … …  
    6156#define USB_HID_UNKNOWN_TAG             -99
    6257
    63 usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t *report, usb_hid_report_path_t *cmp_path)
    64 {
     58
     59/**
     60 * Initialize the report descriptor parser structure
     61 *
     62 * @param parser Report descriptor parser structure
     63 * @return Error code
     64 */
     65int usb_hid_report_init(usb_hid_report_t *report)
     66{
     67        if(report == NULL) {
     68                return EINVAL;
     69        }
     70
     71        memset(report, 0, sizeof(usb_hid_report_t));
     72        list_initialize(&report->reports);
     73        list_initialize(&report->collection_paths);
     74
     75        report->use_report_ids = 0;
     76    return EOK;   
     77}
     78
     79int usb_hid_report_append_fields(usb_hid_report_t *report, usb_hid_report_item_t *report_item)
     80{
     81        usb_hid_report_field_t *field;
     82        int i;
     83
     84
    6585        /* find or append current collection path to the list */
    6686        link_t *path_it = report->collection_paths.next;
    … …  
    6989                path = list_get_instance(path_it, usb_hid_report_path_t, link);
    7090               
    71                 if(usb_hid_report_compare_usage_path(path, cmp_path, USB_HID_PATH_COMPARE_STRICT) == EOK){
     91                if(usb_hid_report_compare_usage_path(path, report_item->usage_path, USB_HID_PATH_COMPARE_STRICT) == EOK){
    7292                        break;
    7393                }                       
    … …  
    7595        }
    7696        if(path_it == &report->collection_paths) {
    77                 path = usb_hid_report_path_clone(cmp_path);                     
     97                path = usb_hid_report_path_clone(report_item->usage_path);                     
    7898                list_append(&path->link, &report->collection_paths);                                   
    7999                report->collection_paths_count++;
    80 
    81                 return path;
    82         }
    83         else {
    84                 return list_get_instance(path_it, usb_hid_report_path_t, link);
    85         }
    86 }
    87 
    88 /**
    89  * Initialize the report descriptor parser structure
    90  *
    91  * @param parser Report descriptor parser structure
    92  * @return Error code
    93  */
    94 int usb_hid_report_init(usb_hid_report_t *report)
    95 {
    96         if(report == NULL) {
    97                 return EINVAL;
    98         }
    99 
    100         memset(report, 0, sizeof(usb_hid_report_t));
    101         list_initialize(&report->reports);
    102         list_initialize(&report->collection_paths);
    103 
    104         report->use_report_ids = 0;
    105     return EOK;   
    106 }
    107 
    108 
    109 /*
    110  *
    111  *
    112  */
    113 int usb_hid_report_append_fields(usb_hid_report_t *report, usb_hid_report_item_t *report_item)
    114 {
    115         usb_hid_report_field_t *field;
    116         int i;
     100        }
    117101
    118102        for(i=0; i<report_item->usages_count; i++){
    … …  
    120104        }
    121105
    122         usb_hid_report_path_t *path = report_item->usage_path; 
     106       
    123107        for(i=0; i<report_item->count; i++){
    124108
    … …  
    128112
    129113                /* fill the attributes */               
     114                field->collection_path = path;
    130115                field->logical_minimum = report_item->logical_minimum;
    131116                field->logical_maximum = report_item->logical_maximum;
    … …  
    144129                if(report_item->usages_count > 0 && ((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0))) {
    145130                        uint32_t usage;
    146                         if(i < report_item->usages_count){
    147                                 usage = report_item->usages[i];
     131                        if(report_item->type != USB_HID_REPORT_TYPE_OUTPUT) {
     132                                if(i < report_item->usages_count){
     133                                        usage = report_item->usages[i];
     134                                }
     135                                else {
     136                                        usage = report_item->usages[report_item->usages_count - 1];
     137                                }
    148138                        }
    149139                        else {
    150                                 usage = report_item->usages[report_item->usages_count - 1];
     140                                if((report_item->count - i - 1) < report_item->usages_count){
     141                                        usage = report_item->usages[(report_item->count - i - 1)];
     142                                }
     143                                else {
     144                                        usage = report_item->usages[report_item->usages_count - 1];
     145                                }
    151146                        }
    152147
    … …  
    164159
    165160                if((USB_HID_ITEM_FLAG_VARIABLE(report_item->item_flags) != 0) && (!((report_item->usage_minimum == 0) && (report_item->usage_maximum == 0)))) {
    166                         field->usage = report_item->usage_minimum + i;                                 
    167                 }
    168                
    169                 usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_GLOBAL, field->usage_page);
    170                 usb_hid_report_set_last_item(path, USB_HID_TAG_CLASS_LOCAL, field->usage);
    171 
    172                 field->collection_path = usb_hid_report_path_try_insert(report, path);
    173 
     161                        if(report_item->type == USB_HID_REPORT_TYPE_INPUT) {
     162                                field->usage = report_item->usage_maximum - i;
     163                        }
     164                        else {
     165                                field->usage = report_item->usage_minimum + i;                                 
     166                        }
     167
     168                }
     169               
    174170                field->size = report_item->size;
    175                
    176                 size_t offset_byte = (report_item->offset + (i * report_item->size)) / 8;
    177                 size_t offset_bit = 8 - ((report_item->offset + (i * report_item->size)) % 8) - report_item->size;
    178 
    179                 field->offset = 8 * offset_byte + offset_bit;
     171                field->offset = report_item->offset + (i * report_item->size);
    180172                if(report_item->id != 0) {
    181173                        field->offset += 8;
    … …  
    272264                return ENOMEM;
    273265        }
    274         usb_hid_report_path_append_item(usage_path, 0, 0);     
    275266       
    276267        while(i<size){ 
    … …  
    358349                                        tmp_usage_path = list_get_instance(report_item->usage_path->link.prev, usb_hid_report_usage_path_t, link);
    359350                                       
    360                                         usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_GLOBAL, tmp_usage_path->usage_page);
    361                                         usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL, tmp_usage_path->usage);
     351                                        usb_hid_report_set_last_item(usage_path, tmp_usage_path->usage_page, tmp_usage_path->usage);
    362352
    363353                                        usb_hid_report_path_free(report_item->usage_path);
    … …  
    437427int usb_hid_report_parse_main_tag(uint8_t tag, const uint8_t *data, size_t item_size,
    438428                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
    439 {
    440         usb_hid_report_usage_path_t *path_item;
    441        
     429{               
    442430        switch(tag)
    443431        {
    … …  
    450438                       
    451439                case USB_HID_REPORT_TAG_COLLECTION:
    452                         // store collection atributes
    453                         path_item = list_get_instance(usage_path->head.prev, usb_hid_report_usage_path_t, link);
    454                         path_item->flags = *data;       
    455                        
    456                         // set last item
    457                         usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_GLOBAL, report_item->usage_page);
    458                         usb_hid_report_set_last_item(usage_path, USB_HID_TAG_CLASS_LOCAL, report_item->usages[report_item->usages_count-1]);
    459                        
    460                         // append the new one which will be set by common
    461                         // usage/usage page
    462                         usb_hid_report_path_append_item(usage_path, report_item->usage_page, report_item->usages[report_item->usages_count-1]);
     440                        // TODO usage_path->flags = *data;
     441                        usb_hid_report_path_append_item(usage_path, report_item->usage_page, report_item->usages[report_item->usages_count-1]);                                         
    463442                        usb_hid_report_reset_local_items (report_item);
    464443                        return USB_HID_NO_ACTION;
    … …  
    551530                             usb_hid_report_item_t *report_item, usb_hid_report_path_t *usage_path)
    552531{
    553         switch(tag) {
     532        switch(tag)
     533        {
    554534                case USB_HID_REPORT_TAG_USAGE:
    555                         switch(report_item->in_delimiter) {
    556                                 case INSIDE_DELIMITER_SET:
    557                                         // nothing to do
    558                                         break;
    559                                 case START_DELIMITER_SET:
    560                                         report_item->in_delimiter = INSIDE_DELIMITER_SET;
    561                                 case OUTSIDE_DELIMITER_SET:
    562                                         report_item->usages[report_item->usages_count] = usb_hid_report_tag_data_uint32(data,item_size);
    563                                         report_item->usages_count++;
    564                                         break;
    565                         }
     535                        report_item->usages[report_item->usages_count] = usb_hid_report_tag_data_uint32(data,item_size);
     536                        report_item->usages_count++;
    566537                        break;
    567538                case USB_HID_REPORT_TAG_USAGE_MINIMUM:
    … …  
    604575                        break;                 
    605576                case USB_HID_REPORT_TAG_DELIMITER:
    606                         report_item->in_delimiter = usb_hid_report_tag_data_uint32(data,item_size);
    607                         break;
    608 
     577                        //report_item->delimiter = usb_hid_report_tag_data_uint32(data,item_size);
     578                        //TODO:
     579                        //      DELIMITER STUFF
     580                        break;
     581               
    609582                default:
    610583                        return USB_HID_NO_ACTION;
    611584        }
    612 
     585       
    613586        return EOK;
    614587}
    … …  
    656629
    657630                usb_log_debug("\t\tOFFSET: %X\n", report_item->offset);
    658                 usb_log_debug("\t\tSIZE: %zu\n", report_item->size);                           
     631                usb_log_debug("\t\tSIZE: %zu\n", report_item->size);
    659632                usb_log_debug("\t\tLOGMIN: %d\n", report_item->logical_minimum);
    660633                usb_log_debug("\t\tLOGMAX: %d\n", report_item->logical_maximum);               
    … …  
    667640                usb_log_debug("\t\ttUSAGE: %X\n", report_item->usage);
    668641                usb_log_debug("\t\tUSAGE PAGE: %X\n", report_item->usage_page);
    669                
    670                 //usb_hid_print_usage_path(report_item->collection_path);
    671 
    672                 usb_log_debug("\n");           
     642                                               
     643//              usb_log_debug("\n");           
    673644
    674645        }
    … …  
    695666                usb_log_debug("Report ID: %d\n", report_des->report_id);
    696667                usb_log_debug("\tType: %d\n", report_des->type);
    697                 usb_log_debug("\tLength: %zu\n", report_des->bit_length);               
    698                 usb_log_debug("\tItems: %zu\n", report_des->item_length);               
     668                usb_log_debug("\tLength: %zu\n", report_des->bit_length);
     669                usb_log_debug("\tItems: %zu\n", report_des->item_length);
    699670
    700671                usb_hid_descriptor_print_list(&report_des->report_items);

  • uspace/lib/usb/src/hidparser.c

    r7ab7c7f6 r5d07f54  
    405405                                }
    406406
    407                                 size_t shift = 8 - offset%8 - length;
     407                                size_t shift = offset%8;
    408408
    409409                                value = value << shift;                                                 

  • uspace/lib/usb/src/hidpath.c

    r7ab7c7f6 r5d07f54  
    149149                usb_log_debug("\tFLAGS: %d\n", path_item->flags);               
    150150               
    151                 item = item->next;
     151                item = item->next;
    152152        }
    153153}
    … …  
    156156 * Compares two usage paths structures
    157157 *
    158  *
    159  * @param report_path usage path structure to compare with @path
     158 * If USB_HID_PATH_COMPARE_COLLECTION_ONLY flag is given, the last item in report_path structure is forgotten
     159 *
     160 * @param report_path usage path structure to compare
    160161 * @param path usage patrh structure to compare
    161162 * @param flags Flags determining the mode of comparison
    … …  
    178179        }
    179180
    180         // Empty path match all others
    181181        if(path->depth == 0){
    182182                return EOK;
    … …  
    189189       
    190190        switch(flags){
    191                 /* path is somewhere in report_path */
    192                 case USB_HID_PATH_COMPARE_ANYWHERE:
    193                         if(path->depth != 1){
    194                                 return 1;
    195                         }
    196 
    197                         // projit skrz cestu a kdyz nekde sedi tak vratim EOK
    198                         // dojduli az za konec tak nnesedi
    199                         report_link = report_path->head.next;
    200                         path_link = path->head.next;
    201                         path_item = list_get_instance(path_link, usb_hid_report_usage_path_t, link);
    202 
    203                         while(report_link != &report_path->head) {
    204                                 report_item = list_get_instance(report_link, usb_hid_report_usage_path_t, link);
    205                                 if(report_item->usage_page == path_item->usage_page){
    206                                         if(only_page == 0){
    207                                                 if(report_item->usage == path_item->usage) {
    208                                                         return EOK;
    209                                                 }
    210                                         }
    211                                         else {
    212                                                 return EOK;
    213                                         }
    214                                 }
    215 
    216                                 report_link = report_link->next;
    217                         }
    218 
    219                         return 1;
    220                         break;
    221                 /* the paths must be identical */
     191                /* path must be completly identical */
    222192                case USB_HID_PATH_COMPARE_STRICT:
    223193                                if(report_path->depth != path->depth){
    224194                                        return 1;
    225195                                }
    226                
    227                 /* path is prefix of the report_path */
    228                 case USB_HID_PATH_COMPARE_BEGIN:
    229        
     196
    230197                                report_link = report_path->head.next;
    231198                                path_link = path->head.next;
    … …  
    254221                                }
    255222
    256                                 if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) && (path_link == &path->head)) ||
    257                                    ((report_link == &report_path->head) && (path_link == &path->head))) {
     223                                if(((report_link == &report_path->head) && (path_link == &path->head)) ||
     224                                   (((flags & USB_HID_PATH_COMPARE_COLLECTION_ONLY) != 0) &&
     225                                    (path_link = &path->head) &&
     226                                    (report_link == report_path->head.prev))) {
    258227                                        return EOK;
    259228                                }
    … …  
    263232                        break;
    264233
    265                 /* path is suffix of report_path */
     234                /* compare with only the end of path*/
    266235                case USB_HID_PATH_COMPARE_END:
    267236
    268                                 report_link = report_path->head.prev;
     237                                if((flags & USB_HID_PATH_COMPARE_COLLECTION_ONLY) != 0) {
     238                                        report_link = report_path->head.prev->prev;
     239                                }
     240                                else {
     241                                        report_link = report_path->head.prev;
     242                                }
    269243                                path_link = path->head.prev;
    270244

  • uspace/lib/usbvirt/Makefile

    r7ab7c7f6 r5d07f54  
    3333
    3434SOURCES = \
     35        src/ipc.c \
    3536        src/ctrltransfer.c \
    36         src/device.c \
    37         src/ipc_dev.c \
    38         src/ipc_hc.c \
    3937        src/stdreq.c \
    4038        src/transfer.c

  • uspace/lib/usbvirt/include/usbvirt/device.h

    r7ab7c7f6 r5d07f54  
    3131 */
    3232/** @file
    33  * Virtual USB device.
     33 * @brief Virtual USB device.
    3434 */
    3535#ifndef LIBUSBVIRT_DEVICE_H_
    … …  
    3939#include <usb/request.h>
    4040
    41 /** Maximum number of endpoints supported by virtual USB. */
    4241#define USBVIRT_ENDPOINT_MAX 16
    4342
    4443typedef struct usbvirt_device usbvirt_device_t;
    4544
    46 /** Callback for data to device (OUT transaction).
    47  *
    48  * @param dev Virtual device to which the transaction belongs.
    49  * @param endpoint Target endpoint number.
    50  * @param transfer_type Transfer type.
    51  * @param buffer Data buffer.
    52  * @param buffer_size Size of the buffer in bytes.
    53  * @return Error code.
    54  */
    55 typedef int (*usbvirt_on_data_to_device_t)(usbvirt_device_t *dev,
    56     usb_endpoint_t endpoint, usb_transfer_type_t transfer_type,
    57     void *buffer, size_t buffer_size);
     45typedef int (*usbvirt_on_data_to_device_t)(usbvirt_device_t *, usb_endpoint_t,
     46    usb_transfer_type_t, void *, size_t);
     47typedef int (*usbvirt_on_data_from_device_t)(usbvirt_device_t *, usb_endpoint_t,
     48    usb_transfer_type_t, void *, size_t, size_t *);
     49typedef int (*usbvirt_on_control_t)(usbvirt_device_t *,
     50    const usb_device_request_setup_packet_t *, uint8_t *, size_t *);
    5851
    59 /** Callback for data from device (IN transaction).
    60  *
    61  * @param dev Virtual device to which the transaction belongs.
    62  * @param endpoint Target endpoint number.
    63  * @param transfer_type Transfer type.
    64  * @param buffer Data buffer to write answer to.
    65  * @param buffer_size Size of the buffer in bytes.
    66  * @param act_buffer_size Write here how many bytes were actually written.
    67  * @return Error code.
    68  */
    69 typedef int (*usbvirt_on_data_from_device_t)(usbvirt_device_t *dev,
    70     usb_endpoint_t endpoint, usb_transfer_type_t transfer_type,
    71     void *buffer, size_t buffer_size, size_t *act_buffer_size);
    72 
    73 /** Callback for control transfer on endpoint zero.
    74  *
    75  * Notice that size of the data buffer is expected to be read from the
    76  * setup packet.
    77  *
    78  * @param dev Virtual device to which the transaction belongs.
    79  * @param setup_packet Standard setup packet.
    80  * @param data Data (might be NULL).
    81  * @param act_data_size Size of returned data in bytes.
    82  * @return Error code.
    83  */
    84 typedef int (*usbvirt_on_control_t)(usbvirt_device_t *dev,
    85     const usb_device_request_setup_packet_t *setup_packet,
    86     uint8_t *data, size_t *act_data_size);
    87 
    88 /** Callback for control request on a virtual USB device.
    89  *
    90  * See usbvirt_control_reply_helper() for simple way of answering
    91  * control read requests.
    92  */
    9352typedef struct {
    94         /** Request direction (in or out). */
    9553        usb_direction_t req_direction;
    96         /** Request recipient (device, interface or endpoint). */
    9754        usb_request_recipient_t req_recipient;
    98         /** Request type (standard, class or vendor). */
    9955        usb_request_type_t req_type;
    100         /** Actual request code. */
    10156        uint8_t request;
    102         /** Request handler name for debugging purposes. */
    10357        const char *name;
    104         /** Callback to be executed on matching request. */
    10558        usbvirt_on_control_t callback;
    10659} usbvirt_control_request_handler_t;
    … …  
    12477} usbvirt_device_configuration_t;
    12578
    126 /** Standard USB descriptors for virtual device. */
     79/** Standard USB descriptors. */
    12780typedef struct {
    12881        /** Standard device descriptor.
    … …  
    149102} usbvirt_device_state_t;
    150103
    151 /** Ops structure for virtual USB device. */
    152104typedef struct {
    153         /** Callbacks for data to device.
    154          * Index zero is ignored.
    155          */
    156105        usbvirt_on_data_to_device_t data_out[USBVIRT_ENDPOINT_MAX];
    157         /** Callbacks for data from device.
    158          * Index zero is ignored.
    159          */
    160106        usbvirt_on_data_from_device_t data_in[USBVIRT_ENDPOINT_MAX];
    161         /** Array of control handlers.
    162          * Last handler is expected to have the @c callback field set to NULL
    163          */
    164107        usbvirt_control_request_handler_t *control;
    165         /** Callback when device changes state.
    166          *
    167          * The value of @c state attribute of @p dev device is not
    168          * defined during call of this function.
    169          *
    170          * @param dev The virtual USB device.
    171          * @param old_state Old device state.
    172          * @param new_state New device state.
    173          */
    174108        void (*state_changed)(usbvirt_device_t *dev,
    175109            usbvirt_device_state_t old_state, usbvirt_device_state_t new_state);
    176110} usbvirt_device_ops_t;
    177111
    178 /** Virtual USB device. */
    179112struct usbvirt_device {
    180         /** Name for debugging purposes. */
    181113        const char *name;
    182         /** Custom device data. */
    183114        void *device_data;
    184         /** Device ops. */
    185115        usbvirt_device_ops_t *ops;
    186         /** Device descriptors. */
    187116        usbvirt_descriptors_t *descriptors;
    188         /** Current device address.
    189          * You shall treat this field as read only in your code.
    190          */
    191117        usb_address_t address;
    192         /** Current device state.
    193          * You shall treat this field as read only in your code.
    194          */
    195118        usbvirt_device_state_t state;
    196         /** Phone to the host controller.
    197          * You shall treat this field as read only in your code.
    198          */
    199         int vhc_phone;
    200119};
    201120
    202121int usbvirt_device_plug(usbvirt_device_t *, const char *);
    203 void usbvirt_device_unplug(usbvirt_device_t *);
    204122
    205123void usbvirt_control_reply_helper(const usb_device_request_setup_packet_t *,

  • uspace/lib/usbvirt/include/usbvirt/ipc.h

    r7ab7c7f6 r5d07f54  
    11/*
    2  * Copyright (c) 2011 Vojtech Horky
     2 * Copyright (c) 2010 Vojtech Horky
    33 * All rights reserved.
    44 *
    … …  
    3131 */
    3232/** @file
    33  * IPC wrappers for virtual USB.
     33 * @brief Virtual USB device.
    3434 */
    3535#ifndef LIBUSBVIRT_IPC_H_
    … …  
    4040#include <bool.h>
    4141
    42 /** IPC methods communication between host controller and virtual device. */
    4342typedef enum {
    4443        IPC_M_USBVIRT_GET_NAME = IPC_FIRST_USER_METHOD + 80,
    … …  
    4645        IPC_M_USBVIRT_CONTROL_WRITE,
    4746        IPC_M_USBVIRT_INTERRUPT_IN,
    48         IPC_M_USBVIRT_INTERRUPT_OUT,
    49         IPC_M_USBVIRT_BULK_IN,
    50         IPC_M_USBVIRT_BULK_OUT
    51 } usbvirt_hc_to_device_method_t;
     47        IPC_M_USBVIRT_INTERRUPT_OUT
     48} usbvirt_ipc_t;
    5249
    53 int usbvirt_ipc_send_control_read(int, void *, size_t,
     50int usbvirt_ipc_send_control_read(int, usb_endpoint_t, void *, size_t,
    5451    void *, size_t, size_t *);
    55 int usbvirt_ipc_send_control_write(int, void *, size_t,
     52int usbvirt_ipc_send_control_write(int, usb_endpoint_t, void *, size_t,
    5653    void *, size_t);
    5754int usbvirt_ipc_send_data_in(int, usb_endpoint_t, usb_transfer_type_t,

  • uspace/lib/usbvirt/src/ctrltransfer.c

    r7ab7c7f6 r5d07f54  
    1 /*
    2  * Copyright (c) 2011 Vojtech Horky
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  *
    9  * - Redistributions of source code must retain the above copyright
    10  *   notice, this list of conditions and the following disclaimer.
    11  * - Redistributions in binary form must reproduce the above copyright
    12  *   notice, this list of conditions and the following disclaimer in the
    13  *   documentation and/or other materials provided with the distribution.
    14  * - The name of the author may not be used to endorse or promote products
    15  *   derived from this software without specific prior written permission.
    16  *
    17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
    18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
    20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
    21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
    22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
    26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    27  */
    28 
    29 /** @addtogroup libusbvirt
    30  * @{
    31  */
    32 /** @file
    33  * Control transfer handling.
    34  */
    351#include "private.h"
    362#include <usb/request.h>
    … …  
    395#include <errno.h>
    406
    41 /** Find and execute control transfer handler for virtual USB device.
    42  *
    43  * @param dev Target virtual device.
    44  * @param control_handlers Array of control request handlers.
    45  * @param setup Setup packet.
    46  * @param data Extra data.
    47  * @param data_sent_size Size of extra data in bytes.
    48  * @return Error code.
    49  * @retval EFORWARD No suitable handler found.
    50  */
    517int process_control_transfer(usbvirt_device_t *dev,
    528    usbvirt_control_request_handler_t *control_handlers,
    … …  
    9652        return EFORWARD;
    9753}
    98 
    99 
    100 /**
    101  * @}
    102  */

  • uspace/lib/usbvirt/src/private.h

    r7ab7c7f6 r5d07f54  
    1 /*
    2  * Copyright (c) 2011 Vojtech Horky
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  *
    9  * - Redistributions of source code must retain the above copyright
    10  *   notice, this list of conditions and the following disclaimer.
    11  * - Redistributions in binary form must reproduce the above copyright
    12  *   notice, this list of conditions and the following disclaimer in the
    13  *   documentation and/or other materials provided with the distribution.
    14  * - The name of the author may not be used to endorse or promote products
    15  *   derived from this software without specific prior written permission.
    16  *
    17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
    18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
    20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
    21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
    22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
    26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    27  */
    28 
    29 /** @addtogroup libusbvirt
    30  * @{
    31  */
    32 /** @file
    33  * Private definitions.
    34  */
    35 #ifndef USBVIRT_PRIVATE_H_
    36 #define USBVIRT_PRIVATE_H_
    37 
    381#include <usbvirt/device.h>
    392
    … …  
    447
    458extern usbvirt_control_request_handler_t library_handlers[];
    46 
    47 #endif
    48 /**
    49  * @}
    50  */

  • uspace/lib/usbvirt/src/stdreq.c

    r7ab7c7f6 r5d07f54  
    1 /*
    2  * Copyright (c) 2011 Vojtech Horky
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  *
    9  * - Redistributions of source code must retain the above copyright
    10  *   notice, this list of conditions and the following disclaimer.
    11  * - Redistributions in binary form must reproduce the above copyright
    12  *   notice, this list of conditions and the following disclaimer in the
    13  *   documentation and/or other materials provided with the distribution.
    14  * - The name of the author may not be used to endorse or promote products
    15  *   derived from this software without specific prior written permission.
    16  *
    17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
    18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
    19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
    20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
    21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
    22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
    26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    27  */
    28 
    29 /** @addtogroup libusbvirt
    30  * @{
    31  */
    32 /** @file
    33  * Standard control request handlers.
    34  */
    351#include "private.h"
    362#include <usb/request.h>
    … …  
    384#include <errno.h>
    395
    40 /** Helper for replying to control read transfer from virtual USB device.
    41  *
    42  * This function takes care of copying data to answer buffer taking care
    43  * of buffer sizes properly.
    44  *
    45  * @param setup_packet The setup packet.
    46  * @param data Data buffer to write to.
    47  * @param act_size Where to write actual size of returned data.
    48  * @param actual_data Data to be returned.
    49  * @param actual_data_size Size of answer data (@p actual_data) in bytes.
    50  */
    516void usbvirt_control_reply_helper(const usb_device_request_setup_packet_t *setup_packet,
    527    uint8_t *data, size_t *act_size,
    … …  
    189144}
    190145
    191 /** Standard request handlers. */
    192146usbvirt_control_request_handler_t library_handlers[] = {
    193147        {
    … …  
    219173};
    220174
    221 /**
    222  * @}
    223  */

  • uspace/lib/usbvirt/src/transfer.c

    r7ab7c7f6 r5d07f54  
    3131 */
    3232/** @file
    33  * Transfer handling.
     33 *
    3434 */
    3535#include <usbvirt/device.h>
    … …  
    3939#include "private.h"
    4040
    41 /** Process a control transfer to the virtual USB device.
    42  *
    43  * @param dev Target device.
    44  * @param setup Setup packet data.
    45  * @param setup_size Size of setup packet.
    46  * @param data Extra data (DATA stage).
    47  * @param data_size Size of extra data in bytes.
    48  * @param data_size_sent Number of actually send bytes during the transfer
    49  *      (only used for READ transfers).
    50  * @return Error code.
    51  */
    5241static int usbvirt_control_transfer(usbvirt_device_t *dev,
    5342    void *setup, size_t setup_size,
    … …  
    8978}
    9079
    91 /** Issue a control write transfer to virtual USB device.
    92  *
    93  * @see usbvirt_control_transfer
    94  *
    95  * @param dev Target virtual device.
    96  * @param setup Setup data.
    97  * @param setup_size Size of setup packet.
    98  * @param data Extra data (DATA stage).
    99  * @param data_size Size of extra data buffer in bytes.
    100  * @return Error code.
    101  */
    10280int usbvirt_control_write(usbvirt_device_t *dev, void *setup, size_t setup_size,
    10381    void *data, size_t data_size)
    … …  
    10785}
    10886
    109 /** Issue a control read transfer to virtual USB device.
    110  *
    111  * @see usbvirt_control_transfer
    112  *
    113  * @param dev Target virtual device.
    114  * @param setup Setup data.
    115  * @param setup_size Size of setup packet.
    116  * @param data Extra data (DATA stage).
    117  * @param data_size Size of extra data buffer in bytes.
    118  * @param data_size_sent Number of actually send bytes during the transfer.
    119  * @return Error code.
    120  */
    12187int usbvirt_control_read(usbvirt_device_t *dev, void *setup, size_t setup_size,
    12288    void *data, size_t data_size, size_t *data_size_sent)
    … …  
    12692}
    12793
    128 /** Send data to virtual USB device.
    129  *
    130  * @param dev Target virtual device.
    131  * @param transf_type Transfer type (interrupt, bulk).
    132  * @param endpoint Endpoint number.
    133  * @param data Data sent from the driver to the device.
    134  * @param data_size Size of the @p data buffer in bytes.
    135  * @return Error code.
    136  */
    13794int usbvirt_data_out(usbvirt_device_t *dev, usb_transfer_type_t transf_type,
    13895    usb_endpoint_t endpoint, void *data, size_t data_size)
    … …  
    151108}
    152109
    153 /** Request data from virtual USB device.
    154  *
    155  * @param dev Target virtual device.
    156  * @param transf_type Transfer type (interrupt, bulk).
    157  * @param endpoint Endpoint number.
    158  * @param data Where to stored data the device returns to the driver.
    159  * @param data_size Size of the @p data buffer in bytes.
    160  * @param data_size_sent Number of actually written bytes.
    161  * @return Error code.
    162  */
    163110int usbvirt_data_in(usbvirt_device_t *dev, usb_transfer_type_t transf_type,
    164111    usb_endpoint_t endpoint, void *data, size_t data_size, size_t *data_size_sent)
Note: See TracChangeset for help on using the changeset viewer.