Changes in / [54d4b9e:98caf49] in mainline


Ignore:
Location:
uspace
Files:
1 added
1 deleted
19 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/usbinfo/Makefile

    r54d4b9e r98caf49  
    4343        dev.c \
    4444        dump.c \
    45         hid.c \
    4645        info.c \
    4746        main.c

  • uspace/app/usbinfo/main.c

    r54d4b9e r98caf49  
    5656        printf("Usage: %s [options] device [device [device [ ... ]]]\n",
    5757            app_name);
    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");
     58        printf(_INDENT "The device is a devman path to the device.\n");
    6159
    6260        _OPTION("-h --help", "Print this help and exit.");
    … …  
    6765        _OPTION("-s --strings", "Try to print all string descriptors.");
    6866        _OPTION("-S --status", "Get status of the device.");
    69         _OPTION("-r --hid-report", "Dump HID report descriptor.");
    7067
    7168        printf("\n");
    … …  
    8582        {"strings", no_argument, NULL, 's'},
    8683        {"status", no_argument, NULL, 'S'},
    87         {"hid-report", no_argument, NULL, 'r'},
    8884        {0, 0, NULL, 0}
    8985};
    90 static const char *short_options = "himtTsSr";
     86static const char *short_options = "himtTsS";
    9187
    9288static usbinfo_action_t actions[] = {
    … …  
    119115                .opt = 'S',
    120116                .action = dump_status,
    121                 .active = false
    122         },
    123         {
    124                 .opt = 'r',
    125                 .action = dump_hidreport,
    126117                .active = false
    127118        },

  • uspace/app/usbinfo/usbinfo.h

    r54d4b9e r98caf49  
    8585void dump_strings(usbinfo_device_t *);
    8686void dump_status(usbinfo_device_t *);
    87 void dump_hidreport(usbinfo_device_t *);
    8887
    8988

  • uspace/drv/ohci/root_hub.c

    r54d4b9e r98caf49  
    251251        int opResult;
    252252        if (request->ep->transfer_type == USB_TRANSFER_CONTROL) {
    253                 usb_log_debug("Root hub got CONTROL packet\n");
     253                usb_log_info("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_debug("Root hub got INTERRUPT packet\n");
     257                usb_log_info("Root hub got INTERRUPT packet\n");
    258258                create_interrupt_mask_in_instance(instance);
    259259                if (is_zeros(instance->interrupt_buffer,

  • uspace/drv/usbhid/Makefile

    r54d4b9e r98caf49  
    4343BINARY = usbhid
    4444
    45 SUBDRIVER_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 
    5345SOURCES = \
    5446        main.c \
    5547        usbhid.c \
    5648        subdrivers.c \
     49        kbd/conv.c \
     50        kbd/kbddev.c \
     51        kbd/kbdrepeat.c \
    5752        generic/hiddev.c \
    58         $(SUBDRIVER_SOURCES)
     53        mouse/mousedev.c \
     54        multimedia/multimedia.c \
     55        multimedia/keymap.c \
     56        $(STOLEN_LAYOUT_SOURCES)
    5957
    6058include $(USPACE_PREFIX)/Makefile.common

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

    r54d4b9e r98caf49  
    231231/*----------------------------------------------------------------------------*/
    232232
    233 bool usb_generic_hid_polling_callback(usb_hid_dev_t *hid_dev, void *data)
    234 {
     233bool 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);
    235239        return true;
    236240}

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

    r54d4b9e r98caf49  
    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);
     52bool usb_generic_hid_polling_callback(struct usb_hid_dev *hid_dev, void *data,
     53    uint8_t *buffer, size_t buffer_size);
    5354
    5455#endif // USB_HID_HIDDDEV_H_

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

    r54d4b9e r98caf49  
    434434 *     usb_hid_parse_report().
    435435 */
    436 static void usb_kbd_process_data(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev)
     436static void usb_kbd_process_data(usb_hid_dev_t *hid_dev, usb_kbd_t *kbd_dev,
     437                                 uint8_t *buffer, size_t actual_size)
    437438{
    438439        assert(hid_dev->report != NULL);
    439440        assert(hid_dev != NULL);
    440441        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));
    441445       
    442446        usb_hid_report_path_t *path = usb_hid_report_path();
    443447        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_KEYBOARD, 0);
    444448
    445         usb_hid_report_path_set_report_id (path, hid_dev->report_id);
     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);
    446459       
    447460        // fill in the currently pressed keys
    … …  
    743756/*----------------------------------------------------------------------------*/
    744757
    745 bool usb_kbd_polling_callback(usb_hid_dev_t *hid_dev, void *data)
    746 {
    747         if (hid_dev == NULL/* || buffer == NULL*/ || data == NULL) {
     758bool 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) {
    748762                // do not continue polling (???)
    749763                return false;
    … …  
    754768       
    755769        // TODO: add return value from this function
    756         usb_kbd_process_data(hid_dev, kbd_dev);
     770        usb_kbd_process_data(hid_dev, kbd_dev, buffer, buffer_size);
    757771       
    758772        return true;
    … …  
    790804        if ((*kbd_dev)->repeat_mtx != NULL) {
    791805                //assert(!fibril_mutex_is_locked((*kbd_dev)->repeat_mtx));
    792                 // FIXME - the fibril_mutex_is_locked may not cause
    793                 // fibril scheduling
    794806                while (fibril_mutex_is_locked((*kbd_dev)->repeat_mtx)) {}
    795807                free((*kbd_dev)->repeat_mtx);

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

    r54d4b9e r98caf49  
    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);
     127bool usb_kbd_polling_callback(struct usb_hid_dev *hid_dev, void *data,
     128                              uint8_t *buffer, size_t buffer_size);
    128129
    129130int usb_kbd_is_initialized(const usb_kbd_t *kbd_dev);

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

    r54d4b9e r98caf49  
    229229/*----------------------------------------------------------------------------*/
    230230
    231 static bool usb_mouse_process_report(usb_hid_dev_t *hid_dev,
    232     usb_mouse_t *mouse_dev)
     231static 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)
    233234{
    234235        assert(mouse_dev != NULL);
     236       
     237        usb_log_debug2("got buffer: %s.\n",
     238            usb_debug_str_buffer(buffer, buffer_size, 0));
    235239       
    236240        if (mouse_dev->mouse_phone < 0) {
    … …  
    240244
    241245        /*
     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       
     263        /*
    242264         * X
    243265         */
    … …  
    248270            USB_HIDUT_USAGE_GENERIC_DESKTOP_X);
    249271
    250         usb_hid_report_path_set_report_id(path, hid_dev->report_id);
     272        usb_hid_report_path_set_report_id(path, report_id);
    251273
    252274        usb_hid_report_field_t *field = usb_hid_report_get_sibling(
    … …  
    271293            USB_HIDUT_USAGE_GENERIC_DESKTOP_Y);
    272294
    273         usb_hid_report_path_set_report_id(path, hid_dev->report_id);
     295        usb_hid_report_path_set_report_id(path, report_id);
    274296
    275297        field = usb_hid_report_get_sibling(
    … …  
    299321            USB_HIDUT_USAGE_GENERIC_DESKTOP_WHEEL);
    300322
    301         usb_hid_report_path_set_report_id(path, hid_dev->report_id);
     323        usb_hid_report_path_set_report_id(path, report_id);
    302324       
    303325        field = usb_hid_report_get_sibling(
    … …  
    323345        path = usb_hid_report_path();
    324346        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_BUTTON, 0);
    325         usb_hid_report_path_set_report_id(path, hid_dev->report_id);
     347        usb_hid_report_path_set_report_id(path, report_id);
    326348       
    327349        field = usb_hid_report_get_sibling(
    … …  
    488510/*----------------------------------------------------------------------------*/
    489511
    490 bool usb_mouse_polling_callback(usb_hid_dev_t *hid_dev, void *data)
     512bool usb_mouse_polling_callback(usb_hid_dev_t *hid_dev, void *data,
     513     uint8_t *buffer, size_t buffer_size)
    491514{
    492515        usb_log_debug("usb_mouse_polling_callback()\n");
     516        usb_debug_str_buffer(buffer, buffer_size, 0);
    493517       
    494518        if (hid_dev == NULL || data == NULL) {
    … …  
    500524        usb_mouse_t *mouse_dev = (usb_mouse_t *)data;
    501525               
    502         return usb_mouse_process_report(hid_dev, mouse_dev);
     526        return usb_mouse_process_report(hid_dev, mouse_dev, buffer,
     527                                        buffer_size);
    503528}
    504529

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

    r54d4b9e r98caf49  
    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);
     67bool usb_mouse_polling_callback(struct usb_hid_dev *hid_dev, void *data,
     68    uint8_t *buffer, size_t buffer_size);
    6869
    6970void usb_mouse_deinit(struct usb_hid_dev *hid_dev, void *data);

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

    r54d4b9e r98caf49  
    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;
    9697       
    9798        if (multim_dev == NULL) {
    … …  
    273274/*----------------------------------------------------------------------------*/
    274275
    275 bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data)
     276bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data,
     277    uint8_t *buffer, size_t buffer_size)
    276278{
    277279        // TODO: checks
    278         if (hid_dev == NULL || data == NULL) {
     280        if (hid_dev == NULL || data == NULL || buffer == NULL) {
    279281                return false;
    280282        }
    281 
     283       
     284        usb_log_debug(NAME " usb_lgtch_polling_callback(%p, %p, %zu)\n",
     285            hid_dev, buffer, buffer_size);
     286       
    282287        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));
    283291       
    284292        usb_hid_report_path_t *path = usb_hid_report_path();
    285293        usb_hid_report_path_append_item(path, USB_HIDUT_PAGE_CONSUMER, 0);
    286294
    287         usb_hid_report_path_set_report_id(path, hid_dev->report_id);
     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);
    288307
    289308        usb_hid_report_field_t *field = usb_hid_report_get_sibling(

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

    r54d4b9e r98caf49  
    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);
     49bool usb_multimedia_polling_callback(struct usb_hid_dev *hid_dev, void *data,
     50    uint8_t *buffer, size_t buffer_size);
    5051
    5152/*----------------------------------------------------------------------------*/

  • uspace/drv/usbhid/subdrivers.h

    r54d4b9e r98caf49  
    4949/*----------------------------------------------------------------------------*/
    5050
    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.
     51/* TODO: This mapping must contain some other information to get the proper
     52 *       interface.
    5753 */
    5854typedef 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          */
    6555        const usb_hid_subdriver_usage_t *usage_path;
    66        
    67         /** Report ID for which the path should apply. */
    6856        int report_id;
    69        
    70         /** Compare type for the Usage path. */
    7157        int compare;
    72        
    73         /** Vendor ID (set to -1 if not specified). */
    7458        int vendor_id;
    75        
    76         /** Product ID (set to -1 if not specified). */
    7759        int product_id;
    78        
    79         /** Subdriver for controlling this device. */
    8060        usb_hid_subdriver_t subdriver;
    8161} usb_hid_subdriver_mapping_t;

  • uspace/drv/usbhid/usbhid.c

    r54d4b9e r98caf49  
    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        
    594584        bool cont = false;
    595585       
    … …  
    598588                if (hid_dev->subdrivers[i].poll != NULL
    599589                    && hid_dev->subdrivers[i].poll(hid_dev,
    600                         hid_dev->subdrivers[i].data)) {
     590                        hid_dev->subdrivers[i].data, buffer, buffer_size)) {
    601591                        cont = true;
    602592                }

  • uspace/drv/usbhid/usbhid.h

    r54d4b9e r98caf49  
    4646#include <bool.h>
    4747
    48 typedef struct usb_hid_dev usb_hid_dev_t;
    49 typedef struct usb_hid_subdriver usb_hid_subdriver_t;
     48struct usb_hid_dev;
    5049
    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  */
    57 typedef int (*usb_hid_driver_init_t)(usb_hid_dev_t *dev, void **data);
     50typedef int (*usb_hid_driver_init_t)(struct usb_hid_dev *, void **data);
     51typedef void (*usb_hid_driver_deinit_t)(struct usb_hid_dev *, void *data);
     52typedef bool (*usb_hid_driver_poll)(struct usb_hid_dev *, void *data, uint8_t *,
     53                                    size_t);
     54typedef int (*usb_hid_driver_poll_ended)(struct usb_hid_dev *, void *data,
     55                                         bool reason);
    5856
    59 /** Subdriver deinitialization callback.
    60  *
    61  * @param dev Backing USB HID device.
    62  * @param data Custom subdriver data.
    63  */
    64 typedef 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  */
    72 typedef 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  */
    81 typedef void (*usb_hid_driver_poll_ended_t)(usb_hid_dev_t *dev, void *data,
    82     bool ended_due_to_errors);
    83 
    84 struct usb_hid_subdriver {
     57typedef struct usb_hid_subdriver {     
    8558        /** Function to be called when initializing HID device. */
    8659        usb_hid_driver_init_t init;
    … …  
    8861        usb_hid_driver_deinit_t deinit;
    8962        /** Function to be called when data arrives from the device. */
    90         usb_hid_driver_poll_t poll;
     63        usb_hid_driver_poll poll;
    9164        /** Function to be called when polling ends. */
    92         usb_hid_driver_poll_ended_t poll_end;
     65        usb_hid_driver_poll_ended poll_end;
    9366        /** Arbitrary data needed by the subdriver. */
    9467        void *data;
    95 };
     68} usb_hid_subdriver_t;
    9669
    9770/*----------------------------------------------------------------------------*/
    … …  
    9972 * Structure for holding general HID device data.
    10073 */
    101 struct usb_hid_dev {
     74typedef struct usb_hid_dev {
    10275        /** Structure holding generic USB device information. */
    10376        usb_device_t *usb_dev;
    … …  
    12194        usb_hid_report_t *report;
    12295       
    123         uint8_t report_id;
    124        
    12596        uint8_t *input_report;
    12697       
    … …  
    129100       
    130101        int report_nr;
    131 };
     102} usb_hid_dev_t;
    132103
    133104/*----------------------------------------------------------------------------*/

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

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

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

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

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

    r54d4b9e r98caf49  
    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 Set Report request to the "
    92                     "device: %s.\n", str_error(rc));
     91                usb_log_warning("Error sending output report to the keyboard: "
     92                    "%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 Set Protocol request to the "
    140                     "device: %s.\n", str_error(rc));
     139                usb_log_warning("Error sending output report to the keyboard: "
     140                    "%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 Set Idle request to the device: "
     189                usb_log_warning("Error sending output report to the keyboard: "
    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 Get Report request to the device: "
     245                usb_log_warning("Error sending output report to the keyboard: "
    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 Get Protocol request to the "
    297                     "device: %s.\n", str_error(rc));
     296                usb_log_warning("Error sending output report to the keyboard: "
     297                    "%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 Get Idle request to the device: "
     359                usb_log_warning("Error sending output report to the keyboard: "
    360360                    "%s.\n", str_error(rc));
    361361                return rc;
Note: See TracChangeset for help on using the changeset viewer.