Changes in / [adfdbd5:bd08239] in mainline


Ignore:
Location:
uspace
Files:
2 added
1 deleted
25 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/mkbd/main.c

    radfdbd5 rbd08239  
    5252#include <usb/hid/hiddescriptor.h>
    5353#include <usb/hid/usages/consumer.h>
     54#include <io/console.h>
     55#include <io/keycode.h>
    5456#include <assert.h>
    5557
    … …  
    166168       
    167169        usb_hid_report_path_free(path);
     170}
     171
     172static int wait_for_quit_fibril(void *arg)
     173{
     174        console_ctrl_t *con = console_init(stdin, stdout);
     175
     176        printf("Press <ESC> to quit the application.\n");
     177
     178        while (1) {
     179                kbd_event_t ev;
     180                bool ok = console_get_kbd_event(con, &ev);
     181                if (!ok) {
     182                        printf("Connection with console broken: %s.\n",
     183                            str_error(errno));
     184                        break;
     185                }
     186
     187                if (ev.key == KC_ESCAPE) {
     188                        break;
     189                }
     190        }
     191
     192        console_done(con);
     193
     194        exit(0);
     195
     196        return EOK;
    168197}
    169198
    … …  
    242271        }
    243272       
     273        fid_t quit_fibril = fibril_create(wait_for_quit_fibril, NULL);
     274        if (quit_fibril == 0) {
     275                printf("Failed to start extra fibril.\n");
     276                return -1;
     277        }
     278        fibril_add_ready(quit_fibril);
     279
    244280        size_t actual_size;
    245281        int event_nr;
    246        
     282
    247283        while (true) {
    248284                /** @todo Try blocking call. */

  • uspace/app/usbinfo/Makefile

    radfdbd5 rbd08239  
    3131
    3232LIBS = \
     33        $(LIBUSBHID_PREFIX)/libusbhid.a \
    3334        $(LIBUSBDEV_PREFIX)/libusbdev.a \
    3435        $(LIBUSB_PREFIX)/libusb.a \
    … …  
    3738        -I$(LIBUSB_PREFIX)/include \
    3839        -I$(LIBUSBDEV_PREFIX)/include \
     40        -I$(LIBUSBHID_PREFIX)/include \
    3941        -I$(LIBDRV_PREFIX)/include
    4042
    … …  
    4345        dev.c \
    4446        dump.c \
     47        hid.c \
    4548        info.c \
    4649        main.c

  • uspace/app/usbinfo/main.c

    radfdbd5 rbd08239  
    5656        printf("Usage: %s [options] device [device [device [ ... ]]]\n",
    5757            app_name);
    58         printf(_INDENT "The device is a devman path to the device.\n");
     58        printf(_INDENT "The device can be specified in two ways.\n");
     59        printf(_INDENT "  o Using its devman path, e.g. /hw/pci0/.../usb00_a1.\n");
     60        printf(_INDENT "  o Or using BUS.ADDR numbers as printed by lsusb.\n");
    5961
    6062        _OPTION("-h --help", "Print this help and exit.");
    … …  
    6567        _OPTION("-s --strings", "Try to print all string descriptors.");
    6668        _OPTION("-S --status", "Get status of the device.");
     69        _OPTION("-r --hid-report", "Dump HID report descriptor.");
     70        _OPTION("-r --hid-report-usages", "Dump usages of HID report.");
    6771
    6872        printf("\n");
    … …  
    8286        {"strings", no_argument, NULL, 's'},
    8387        {"status", no_argument, NULL, 'S'},
     88        {"hid-report", no_argument, NULL, 'r'},
     89        {"hid-report-usages", no_argument, NULL, 'R'},
    8490        {0, 0, NULL, 0}
    8591};
    86 static const char *short_options = "himtTsS";
     92static const char *short_options = "himtTsSrR";
    8793
    8894static usbinfo_action_t actions[] = {
    … …  
    115121                .opt = 'S',
    116122                .action = dump_status,
     123                .active = false
     124        },
     125        {
     126                .opt = 'r',
     127                .action = dump_hidreport_raw,
     128                .active = false
     129        },
     130        {
     131                .opt = 'R',
     132                .action = dump_hidreport_usages,
    117133                .active = false
    118134        },

  • uspace/app/usbinfo/usbinfo.h

    radfdbd5 rbd08239  
    8585void dump_strings(usbinfo_device_t *);
    8686void dump_status(usbinfo_device_t *);
     87void dump_hidreport_raw(usbinfo_device_t *);
     88void dump_hidreport_usages(usbinfo_device_t *);
    8789
    8890

  • uspace/app/vuhid/Makefile

    radfdbd5 rbd08239  
    3636        $(LIBUSBHID_PREFIX)/libusbhid.a \
    3737        $(LIBUSBDEV_PREFIX)/libusbdev.a \
    38         $(LIBUSB_PREFIX)/libusb.a
     38        $(LIBUSB_PREFIX)/libusb.a \
     39        $(LIBDRV_PREFIX)/libdrv.a
    3940EXTRA_CFLAGS = \
    4041        -I$(LIBUSB_PREFIX)/include \

  • uspace/drv/ohci/root_hub.c

    radfdbd5 rbd08239  
    251251        int opResult;
    252252        if (request->ep->transfer_type == USB_TRANSFER_CONTROL) {
    253                 usb_log_info("Root hub got CONTROL packet\n");
     253                usb_log_debug("Root hub got CONTROL packet\n");
    254254                opResult = process_ctrl_request(instance, request);
    255255                usb_transfer_batch_finish_error(request, opResult);
    256256        } else if (request->ep->transfer_type == USB_TRANSFER_INTERRUPT) {
    257                 usb_log_info("Root hub got INTERRUPT packet\n");
     257                usb_log_debug("Root hub got INTERRUPT packet\n");
    258258                create_interrupt_mask_in_instance(instance);
    259259                if (is_zeros(instance->interrupt_buffer,

  • uspace/drv/usbhid/Makefile

    radfdbd5 rbd08239  
    4343BINARY = usbhid
    4444
     45SUBDRIVER_SOURCES = \
     46        kbd/conv.c \
     47        kbd/kbddev.c \
     48        kbd/kbdrepeat.c \
     49        mouse/mousedev.c \
     50        multimedia/multimedia.c \
     51        multimedia/keymap.c
     52
    4553SOURCES = \
    4654        main.c \
    4755        usbhid.c \
    4856        subdrivers.c \
    49         kbd/conv.c \
    50         kbd/kbddev.c \
    51         kbd/kbdrepeat.c \
    5257        generic/hiddev.c \
    53         mouse/mousedev.c \
    54         multimedia/multimedia.c \
    55         multimedia/keymap.c \
    56         $(STOLEN_LAYOUT_SOURCES)
     58        $(SUBDRIVER_SOURCES)
    5759
    5860include $(USPACE_PREFIX)/Makefile.common

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

    radfdbd5 rbd08239  
    231231/*----------------------------------------------------------------------------*/
    232232
    233 bool usb_generic_hid_polling_callback(usb_hid_dev_t *hid_dev, void *data,
    234     uint8_t *buffer, size_t buffer_size)
    235 {
    236         usb_log_debug2("usb_hid_polling_callback(%p, %p, %zu)\n",
    237             hid_dev, buffer, buffer_size);
    238         usb_debug_str_buffer(buffer, buffer_size, 0);
     233bool usb_generic_hid_polling_callback(usb_hid_dev_t *hid_dev, void *data)
     234{
    239235        return true;
    240236}

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

    radfdbd5 rbd08239  
    5050int usb_generic_hid_init(struct usb_hid_dev *hid_dev, void **data);
    5151
    52 bool usb_generic_hid_polling_callback(struct usb_hid_dev *hid_dev, void *data,
    53     uint8_t *buffer, size_t buffer_size);
     52bool usb_generic_hid_polling_callback(struct usb_hid_dev *hid_dev, void *data);
    5453
    5554#endif // USB_HID_HIDDDEV_H_

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

    radfdbd5 rbd08239  
    4646#include <fibril.h>
    4747#include <fibril_synch.h>
     48
     49#include <ddf/log.h>
    4850
    4951#include <usb/usb.h>
    … …  
    408410        memcpy(kbd_dev->keys_old, kbd_dev->keys, kbd_dev->key_count * 4);
    409411       
    410         usb_log_debug2("New stored keys: ");
    411         for (i = 0; i < kbd_dev->key_count; ++i) {
    412                 usb_log_debug2("%d ", kbd_dev->keys_old[i]);
    413         }
    414         usb_log_debug2("\n");
     412        char key_buffer[512];
     413        ddf_dump_buffer(key_buffer, 512,
     414            kbd_dev->keys_old, 4, kbd_dev->key_count, 0);
     415        usb_log_debug2("Stored keys %s.\n", key_buffer);
    415416}
    416417
    … …  
    434435 *     usb_hid_parse_report().
    435436 */
    436 static void usb_kbd_process_data(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev,
    437                                  uint8_t *buffer, size_t actual_size)
     437static void usb_kbd_process_data(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev)
    438438{
    439439        assert(hid_dev->report != NULL);
    440440        assert(hid_dev != NULL);
    441441        assert(kbd_dev != NULL);
    442 
    443         usb_log_debug("Calling usb_hid_parse_report() with "
    444             "buffer %s\n", usb_debug_str_buffer(buffer, actual_size, 0));
    445442       
    446443        usb_hid_report_path_t *path = usb_hid_report_path();
    447444        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
    448445
    449         uint8_t report_id;
    450         int rc = usb_hid_parse_report(hid_dev->report, buffer, actual_size,
    451             &report_id);
    452        
    453         if (rc != EOK) {
    454                 usb_log_warning("Error in usb_hid_parse_report():"
    455                     "%s\n", str_error(rc));
    456         }
    457        
    458         usb_hid_report_path_set_report_id (path, report_id);
     446        usb_hid_report_path_set_report_id (path, hid_dev->report_id);
    459447       
    460448        // fill in the currently pressed keys
    … …  
    756744/*----------------------------------------------------------------------------*/
    757745
    758 bool usb_kbd_polling_callback(usb_hid_dev_t *hid_dev, void *data,
    759      uint8_t *buffer, size_t buffer_size)
    760 {
    761         if (hid_dev == NULL || buffer == NULL || data == NULL) {
     746bool usb_kbd_polling_callback(usb_hid_dev_t *hid_dev, void *data)
     747{
     748        if (hid_dev == NULL/* || buffer == NULL*/ || data == NULL) {
    762749                // do not continue polling (???)
    763750                return false;
    … …  
    768755       
    769756        // TODO: add return value from this function
    770         usb_kbd_process_data(hid_dev, kbd_dev, buffer, buffer_size);
     757        usb_kbd_process_data(hid_dev, kbd_dev);
    771758       
    772759        return true;
    … …  
    804791        if ((*kbd_dev)->repeat_mtx != NULL) {
    805792                //assert(!fibril_mutex_is_locked((*kbd_dev)->repeat_mtx));
     793                // FIXME - the fibril_mutex_is_locked may not cause
     794                // fibril scheduling
    806795                while (fibril_mutex_is_locked((*kbd_dev)->repeat_mtx)) {}
    807796                free((*kbd_dev)->repeat_mtx);

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

    radfdbd5 rbd08239  
    125125int usb_kbd_init(struct usb_hid_dev *hid_dev, void **data);
    126126
    127 bool usb_kbd_polling_callback(struct usb_hid_dev *hid_dev, void *data,
    128                               uint8_t *buffer, size_t buffer_size);
     127bool usb_kbd_polling_callback(struct usb_hid_dev *hid_dev, void *data);
    129128
    130129int usb_kbd_is_initialized(const usb_kbd_t *kbd_dev);

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

    radfdbd5 rbd08239  
    229229/*----------------------------------------------------------------------------*/
    230230
    231 static bool usb_mouse_process_report(usb_hid_dev_t *hid_dev,
    232                                      usb_mouse_t *mouse_dev, uint8_t *buffer,
    233                                      size_t buffer_size)
     231static bool usb_mouse_process_report(usb_hid_dev_t *hid_dev,
     232    usb_mouse_t *mouse_dev)
    234233{
    235234        assert(mouse_dev != NULL);
    236        
    237         usb_log_debug2("got buffer: %s.\n",
    238             usb_debug_str_buffer(buffer, buffer_size, 0));
    239235       
    240236        if (mouse_dev->mouse_phone < 0) {
    … …  
    243239        }
    244240
    245         /*
    246          * parse the input report
    247          */
    248        
    249         usb_log_debug(NAME " Calling usb_hid_parse_report() with "
    250             "buffer %s\n", usb_debug_str_buffer(buffer, buffer_size, 0));
    251        
    252         uint8_t report_id;
    253        
    254         int rc = usb_hid_parse_report(hid_dev->report, buffer, buffer_size,
    255             &report_id);
    256        
    257         if (rc != EOK) {
    258                 usb_log_warning(NAME "Error in usb_hid_parse_report(): %s\n",
    259                     str_error(rc));
    260                 return true;
    261         }
    262        
    263241        /*
    264242         * X
    … …  
    270248            USB_HIDUT_USAGE_GENERIC_DESKTOP_X);
    271249
    272         usb_hid_report_path_set_report_id(path, report_id);
     250        usb_hid_report_path_set_report_id(path, hid_dev->report_id);
    273251
    274252        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
    … …  
    293271            USB_HIDUT_USAGE_GENERIC_DESKTOP_Y);
    294272
    295         usb_hid_report_path_set_report_id(path, report_id);
     273        usb_hid_report_path_set_report_id(path, hid_dev->report_id);
    296274
    297275        field = usb_hid_report_get_sibling(
    … …  
    321299            USB_HIDUT_USAGE_GENERIC_DESKTOP_WHEEL);
    322300
    323         usb_hid_report_path_set_report_id(path, report_id);
     301        usb_hid_report_path_set_report_id(path, hid_dev->report_id);
    324302       
    325303        field = usb_hid_report_get_sibling(
    … …  
    345323        path = usb_hid_report_path();
    346324        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_BUTTON, 0);
    347         usb_hid_report_path_set_report_id(path, report_id);
     325        usb_hid_report_path_set_report_id(path, hid_dev->report_id);
    348326       
    349327        field = usb_hid_report_get_sibling(
    … …  
    510488/*----------------------------------------------------------------------------*/
    511489
    512 bool usb_mouse_polling_callback(usb_hid_dev_t *hid_dev, void *data,
    513      uint8_t *buffer, size_t buffer_size)
     490bool usb_mouse_polling_callback(usb_hid_dev_t *hid_dev, void *data)
    514491{
    515492        usb_log_debug("usb_mouse_polling_callback()\n");
    516         usb_debug_str_buffer(buffer, buffer_size, 0);
    517493       
    518494        if (hid_dev == NULL || data == NULL) {
    … …  
    524500        usb_mouse_t *mouse_dev = (usb_mouse_t *)data;
    525501               
    526         return usb_mouse_process_report(hid_dev, mouse_dev, buffer,
    527                                         buffer_size);
     502        return usb_mouse_process_report(hid_dev, mouse_dev);
    528503}
    529504

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

    radfdbd5 rbd08239  
    6565int usb_mouse_init(struct usb_hid_dev *hid_dev, void **data);
    6666
    67 bool usb_mouse_polling_callback(struct usb_hid_dev *hid_dev, void *data,
    68     uint8_t *buffer, size_t buffer_size);
     67bool usb_mouse_polling_callback(struct usb_hid_dev *hid_dev, void *data);
    6968
    7069void usb_mouse_deinit(struct usb_hid_dev *hid_dev, void *data);

  • uspace/drv/usbhid/multimedia/multimedia.c

    radfdbd5 rbd08239  
    9494       
    9595        usb_multimedia_t *multim_dev = (usb_multimedia_t *)fun->driver_data;
    96         //usb_hid_dev_t *hid_dev = (usb_hid_dev_t *)fun->driver_data;
    9796       
    9897        if (multim_dev == NULL) {
    … …  
    274273/*----------------------------------------------------------------------------*/
    275274
    276 bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data,
    277     uint8_t *buffer, size_t buffer_size)
     275bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data)
    278276{
    279277        // TODO: checks
    280         if (hid_dev == NULL || data == NULL || buffer == NULL) {
     278        if (hid_dev == NULL || data == NULL) {
    281279                return false;
    282280        }
    283        
    284         usb_log_debug(NAME " usb_lgtch_polling_callback(%p, %p, %zu)\n",
    285             hid_dev, buffer, buffer_size);
    286        
     281
    287282        usb_multimedia_t *multim_dev = (usb_multimedia_t *)data;
    288 
    289         usb_log_debug(NAME " Calling usb_hid_parse_report() with "
    290             "buffer %s\n", usb_debug_str_buffer(buffer, buffer_size, 0));
    291283       
    292284        usb_hid_report_path_t *path = usb_hid_report_path();
    293285        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
    294286
    295         uint8_t report_id;
    296        
    297         int rc = usb_hid_parse_report(hid_dev->report, buffer, buffer_size,
    298             &report_id);
    299        
    300         if (rc != EOK) {
    301                 usb_log_warning(NAME "Error in usb_hid_parse_report(): %s\n",
    302                     str_error(rc));
    303                 return true;
    304         }
    305        
    306         usb_hid_report_path_set_report_id(path, report_id);
     287        usb_hid_report_path_set_report_id(path, hid_dev->report_id);
    307288
    308289        usb_hid_report_field_t *field = usb_hid_report_get_sibling(

  • uspace/drv/usbhid/multimedia/multimedia.h

    radfdbd5 rbd08239  
    4747void usb_multimedia_deinit(struct usb_hid_dev *hid_dev, void *data);
    4848
    49 bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data,
    50     uint8_t *buffer, size_t buffer_size);
     49bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data);
    5150
    5251/*----------------------------------------------------------------------------*/

  • uspace/drv/usbhid/subdrivers.h

    radfdbd5 rbd08239  
    4949/*----------------------------------------------------------------------------*/
    5050
    51 /* TODO: This mapping must contain some other information to get the proper
    52  *       interface.
     51/** Structure representing the mapping between device requirements and the
     52 *  subdriver supposed to handle this device.
     53 *
     54 * By filling in this structure and adding it to the usb_hid_subdrivers array,
     55 * a new subdriver mapping will be created and used by the HID driver when it
     56 * searches for appropriate subdrivers for a device.
    5357 */
    5458typedef struct usb_hid_subdriver_mapping {
     59        /** Usage path that the device's Input reports must contain.
     60         *
     61         * It is an array of pairs <usage_page, usage>, terminated by a <0, 0>
     62         * pair. If you do not wish to specify the device in this way, set this
     63         * to NULL.
     64         */
    5565        const usb_hid_subdriver_usage_t *usage_path;
     66       
     67        /** Report ID for which the path should apply. */
    5668        int report_id;
     69       
     70        /** Compare type for the Usage path. */
    5771        int compare;
     72       
     73        /** Vendor ID (set to -1 if not specified). */
    5874        int vendor_id;
     75       
     76        /** Product ID (set to -1 if not specified). */
    5977        int product_id;
     78       
     79        /** Subdriver for controlling this device. */
    6080        usb_hid_subdriver_t subdriver;
    6181} usb_hid_subdriver_mapping_t;

  • uspace/drv/usbhid/usbhid.c

    radfdbd5 rbd08239  
    582582        }
    583583       
     584        // parse the input report
     585       
     586        int rc = usb_hid_parse_report(hid_dev->report, buffer, buffer_size,
     587            &hid_dev->report_id);
     588       
     589        if (rc != EOK) {
     590                usb_log_warning("Error in usb_hid_parse_report():"
     591                    "%s\n", str_error(rc));
     592        }       
     593       
    584594        bool cont = false;
    585595       
    … …  
    588598                if (hid_dev->subdrivers[i].poll != NULL
    589599                    && hid_dev->subdrivers[i].poll(hid_dev,
    590                         hid_dev->subdrivers[i].data, buffer, buffer_size)) {
     600                        hid_dev->subdrivers[i].data)) {
    591601                        cont = true;
    592602                }

  • uspace/drv/usbhid/usbhid.h

    radfdbd5 rbd08239  
    4646#include <bool.h>
    4747
    48 struct usb_hid_dev;
     48typedef struct usb_hid_dev usb_hid_dev_t;
     49typedef struct usb_hid_subdriver usb_hid_subdriver_t;
    4950
    50 typedef int (*usb_hid_driver_init_t)(struct usb_hid_dev *, void **data);
    51 typedef void (*usb_hid_driver_deinit_t)(struct usb_hid_dev *, void *data);
    52 typedef bool (*usb_hid_driver_poll)(struct usb_hid_dev *, void *data, uint8_t *,
    53                                     size_t);
    54 typedef int (*usb_hid_driver_poll_ended)(struct usb_hid_dev *, void *data,
    55                                          bool reason);
     51/** Subdriver initialization callback.
     52 *
     53 * @param dev Backing USB HID device.
     54 * @param data Custom subdriver data (pointer where to store them).
     55 * @return Error code.
     56 */
     57typedef int (*usb_hid_driver_init_t)(usb_hid_dev_t *dev, void **data);
    5658
    57 typedef struct usb_hid_subdriver {     
     59/** Subdriver deinitialization callback.
     60 *
     61 * @param dev Backing USB HID device.
     62 * @param data Custom subdriver data.
     63 */
     64typedef void (*usb_hid_driver_deinit_t)(usb_hid_dev_t *dev, void *data);
     65
     66/** Subdriver callback on data from device.
     67 *
     68 * @param dev Backing USB HID device.
     69 * @param data Custom subdriver data.
     70 * @return Whether to continue polling (typically true always).
     71 */
     72typedef bool (*usb_hid_driver_poll_t)(usb_hid_dev_t *dev, void *data);
     73
     74/** Subdriver callback after communication with the device ceased.
     75 *
     76 * @param dev Backing USB HID device.
     77 * @param data Custom subdriver data.
     78 * @param ended_due_to_errors Whether communication ended due to errors in
     79 *      communication (true) or deliberately by driver (false).
     80 */
     81typedef void (*usb_hid_driver_poll_ended_t)(usb_hid_dev_t *dev, void *data,
     82    bool ended_due_to_errors);
     83
     84struct usb_hid_subdriver {
    5885        /** Function to be called when initializing HID device. */
    5986        usb_hid_driver_init_t init;
    … …  
    6188        usb_hid_driver_deinit_t deinit;
    6289        /** Function to be called when data arrives from the device. */
    63         usb_hid_driver_poll poll;
     90        usb_hid_driver_poll_t poll;
    6491        /** Function to be called when polling ends. */
    65         usb_hid_driver_poll_ended poll_end;
     92        usb_hid_driver_poll_ended_t poll_end;
    6693        /** Arbitrary data needed by the subdriver. */
    6794        void *data;
    68 } usb_hid_subdriver_t;
     95};
    6996
    7097/*----------------------------------------------------------------------------*/
    … …  
    7299 * Structure for holding general HID device data.
    73100 */
    74 typedef struct usb_hid_dev {
     101struct usb_hid_dev {
    75102        /** Structure holding generic USB device information. */
    76103        usb_device_t *usb_dev;
    … …  
    94121        usb_hid_report_t *report;
    95122       
     123        uint8_t report_id;
     124       
    96125        uint8_t *input_report;
    97126       
    … …  
    100129       
    101130        int report_nr;
    102 } usb_hid_dev_t;
     131};
    103132
    104133/*----------------------------------------------------------------------------*/

  • uspace/lib/c/generic/str.c

    radfdbd5 rbd08239  
    540540
    541541        dstr_size = str_size(dest);
     542        if (dstr_size >= size) {
     543                return;
     544        }
    542545        str_cpy(dest + dstr_size, size - dstr_size, src);
    543546}

  • uspace/lib/drv/Makefile

    radfdbd5 rbd08239  
    3636        generic/dev_iface.c \
    3737        generic/log.c \
     38        generic/logbuf.c \
    3839        generic/remote_hw_res.c \
    3940        generic/remote_char_dev.c \

  • uspace/lib/drv/include/ddf/log.h

    radfdbd5 rbd08239  
    3939extern void ddf_msg(log_level_t, const char *, ...);
    4040
     41extern void ddf_dump_buffer(char *, size_t, const void *, size_t, size_t,
     42    size_t);
     43
    4144#endif
    4245

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

    radfdbd5 rbd08239  
    3838#include <stdlib.h>
    3939#include <stdio.h>
     40#include <ddf/log.h>
    4041#include <usb/debug.h>
    4142
    … …  
    193194        bzero(buffer_dump[buffer_dump_index], BUFFER_DUMP_LEN);
    194195
    195         if (buffer == NULL) {
    196                 return "(null)";
    197         }
    198         if (size == 0) {
    199                 return "(empty)";
    200         }
    201         if ((dumped_size == 0) || (dumped_size > size)) {
    202                 dumped_size = size;
    203         }
    204 
    205         /* How many bytes are available in the output buffer. */
    206         size_t buffer_remaining_size = BUFFER_DUMP_LEN - 1 - REMAINDER_STR_LEN;
    207         char *it = buffer_dump[buffer_dump_index];
    208 
    209         size_t index = 0;
    210 
    211         while (index < size) {
    212                 /* Determine space before the number. */
    213                 const char *space_before;
    214                 if (index == 0) {
    215                         space_before = "";
    216                 } else if ((index % BUFFER_DUMP_GROUP_SIZE) == 0) {
    217                         space_before = "  ";
    218                 } else {
    219                         space_before = " ";
    220                 }
    221 
    222                 /*
    223                  * Add the byte as a hexadecimal number plus the space.
    224                  * We do it into temporary buffer to ensure that always
    225                  * the whole byte is printed.
    226                  */
    227                 int val = buffer[index];
    228                 char current_byte[16];
    229                 int printed = snprintf(current_byte, 16,
    230                     "%s%02x", space_before, val);
    231                 if (printed < 0) {
    232                         break;
    233                 }
    234 
    235                 if ((size_t) printed > buffer_remaining_size) {
    236                         break;
    237                 }
    238 
    239                 /* We can safely add 1, because space for end 0 is reserved. */
    240                 str_append(it, buffer_remaining_size + 1, current_byte);
    241 
    242                 buffer_remaining_size -= printed;
    243                 /* Point at the terminator 0. */
    244                 it += printed;
    245                 index++;
    246 
    247                 if (index >= dumped_size) {
    248                         break;
    249                 }
    250         }
    251 
    252         /* Add how many bytes were not printed. */
    253         if (index < size) {
    254                 snprintf(it, REMAINDER_STR_LEN,
    255                     REMAINDER_STR_FMT, size - index);
    256         }
     196        /* Do the actual dump. */
     197        ddf_dump_buffer(buffer_dump[buffer_dump_index], BUFFER_DUMP_LEN,
     198            buffer, 1, size, dumped_size);
    257199
    258200        /* Next time, use the other buffer. */

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

    radfdbd5 rbd08239  
    9898                return EBUSY;
    9999       
    100         async_sess_t *sess = devman_device_connect(EXCHANGE_SERIALIZE,
     100        async_sess_t *sess = devman_device_connect(EXCHANGE_ATOMIC,
    101101            connection->hc_handle, 0);
    102102        if (!sess)
    … …  
    177177{
    178178        async_sess_t *parent_sess =
    179             devman_parent_device_connect(EXCHANGE_SERIALIZE, dev_handle,
     179            devman_parent_device_connect(EXCHANGE_ATOMIC, dev_handle,
    180180            IPC_FLAG_BLOCKING);
    181181        if (!parent_sess)
    … …  
    241241{
    242242        async_sess_t *parent_sess =
    243             devman_parent_device_connect(EXCHANGE_SERIALIZE, device_handle,
     243            devman_parent_device_connect(EXCHANGE_ATOMIC, device_handle,
    244244            IPC_FLAG_BLOCKING);
    245245        if (!parent_sess)

  • uspace/lib/usbdev/src/pipes.c

    radfdbd5 rbd08239  
    8181{
    8282        async_sess_t *parent_sess =
    83             devman_parent_device_connect(EXCHANGE_SERIALIZE, device->handle,
     83            devman_parent_device_connect(EXCHANGE_ATOMIC, device->handle,
    8484            IPC_FLAG_BLOCKING);
    8585        if (!parent_sess)
    … …  
    122122       
    123123        async_sess_t *parent_sess =
    124             devman_parent_device_connect(EXCHANGE_SERIALIZE, dev->handle,
     124            devman_parent_device_connect(EXCHANGE_ATOMIC, dev->handle,
    125125            IPC_FLAG_BLOCKING);
    126126        if (!parent_sess)

  • uspace/lib/usbhid/src/hidreq.c

    radfdbd5 rbd08239  
    8282        value |= (type << 8);
    8383
    84         usb_log_debug("Sending Set_Report request to the device.\n");
     84        usb_log_debug("Sending Set Report request to the device.\n");
    8585       
    8686        rc = usb_control_request_set(ctrl_pipe,
    … …  
    8989
    9090        if (rc != EOK) {
    91                 usb_log_warning("Error sending output report to the keyboard: "
    92                     "%s.\n", str_error(rc));
     91                usb_log_warning("Error sending Set Report request to the "
     92                    "device: %s.\n", str_error(rc));
    9393                return rc;
    9494        }
    … …  
    129129        int rc;
    130130
    131         usb_log_debug("Sending Set_Protocol request to the device ("
     131        usb_log_debug("Sending Set Protocol request to the device ("
    132132            "protocol: %d, iface: %d).\n", protocol, iface_no);
    133133       
    … …  
    137137
    138138        if (rc != EOK) {
    139                 usb_log_warning("Error sending output report to the keyboard: "
    140                     "%s.\n", str_error(rc));
     139                usb_log_warning("Error sending Set Protocol request to the "
     140                    "device: %s.\n", str_error(rc));
    141141                return rc;
    142142        }
    … …  
    177177        int rc;
    178178
    179         usb_log_debug("Sending Set_Idle request to the device ("
     179        usb_log_debug("Sending Set Idle request to the device ("
    180180            "duration: %u, iface: %d).\n", duration, iface_no);
    181181       
    … …  
    187187
    188188        if (rc != EOK) {
    189                 usb_log_warning("Error sending output report to the keyboard: "
     189                usb_log_warning("Error sending Set Idle request to the device: "
    190190                    "%s.\n", str_error(rc));
    191191                return rc;
    … …  
    235235        value |= (type << 8);
    236236       
    237         usb_log_debug("Sending Get_Report request to the device.\n");
     237        usb_log_debug("Sending Get Report request to the device.\n");
    238238       
    239239        rc = usb_control_request_get(ctrl_pipe,
    … …  
    243243
    244244        if (rc != EOK) {
    245                 usb_log_warning("Error sending output report to the keyboard: "
     245                usb_log_warning("Error sending Get Report request to the device: "
    246246                    "%s.\n", str_error(rc));
    247247                return rc;
    … …  
    283283        int rc;
    284284
    285         usb_log_debug("Sending Get_Protocol request to the device ("
     285        usb_log_debug("Sending Get Protocol request to the device ("
    286286            "iface: %d).\n", iface_no);
    287287       
    … …  
    294294
    295295        if (rc != EOK) {
    296                 usb_log_warning("Error sending output report to the keyboard: "
    297                     "%s.\n", str_error(rc));
     296                usb_log_warning("Error sending Get Protocol request to the "
     297                    "device: %s.\n", str_error(rc));
    298298                return rc;
    299299        }
    … …  
    344344        int rc;
    345345
    346         usb_log_debug("Sending Get_Idle request to the device ("
     346        usb_log_debug("Sending Get Idle request to the device ("
    347347            "iface: %d).\n", iface_no);
    348348       
    … …  
    357357
    358358        if (rc != EOK) {
    359                 usb_log_warning("Error sending output report to the keyboard: "
     359                usb_log_warning("Error sending Get Idle request to the device: "
    360360                    "%s.\n", str_error(rc));
    361361                return rc;
Note: See TracChangeset for help on using the changeset viewer.