Changes in / [45a2688:5f7b75a] in mainline


Ignore:
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/include/ddi/irq.h

    r45a2688 r5f7b75a  
    7777         */
    7878        CMD_PIO_WRITE_A_32,
    79 
    80         /** Read 1 byte from the memory space. */
    81         CMD_MEM_READ_8,
    82         /** Read 2 bytes from the memory space. */
    83         CMD_MEM_READ_16,
    84         /** Read 4 bytes from the memory space. */
    85         CMD_MEM_READ_32,
    86 
    87         /** Write 1 byte to the memory space. */
    88         CMD_MEM_WRITE_8,
    89         /** Write 2 bytes to the memory space. */
    90         CMD_MEM_WRITE_16,
    91         /** Write 4 bytes to the memory space. */
    92         CMD_MEM_WRITE_32,
    93 
    94         /** Write 1 byte from the source argument to the memory space. */
    95         CMD_MEM_WRITE_A_8,
    96         /** Write 2 bytes from the source argument to the memory space. */
    97         CMD_MEM_WRITE_A_16,
    98         /** Write 4 bytes from the source argument to the memory space. */
    99         CMD_MEM_WRITE_A_32,
    100 
     79       
    10180        /**
    10281         * Perform a bit masking on the source argument
    … …  
    224203        /** Notification configuration structure. */
    225204        ipc_notif_cfg_t notif_cfg;
    226 
    227         as_t *driver_as;
    228205} irq_t;
    229206

  • kernel/generic/src/ipc/irq.c

    r45a2688 r5f7b75a  
    174174        irq->notif_cfg.code = code;
    175175        irq->notif_cfg.counter = 0;
    176         irq->driver_as = AS;
    177176       
    178177        /*
    … …  
    365364                return IRQ_DECLINE;
    366365       
    367 #define CMD_MEM_READ(target) \
    368 do { \
    369         void *va = code->cmds[i].addr; \
    370         if (AS != irq->driver_as) \
    371                 as_switch(AS, irq->driver_as); \
    372         printf("Copying data from address: %p.\n", va); \
    373         memcpy_from_uspace(&target, va, (sizeof(target))); \
    374         if (dstarg) \
    375                 scratch[dstarg] = target; \
    376 } while(0)
    377 
    378 #define CMD_MEM_WRITE(val) \
    379 do { \
    380         void *va = code->cmds[i].addr; \
    381         if (AS != irq->driver_as) \
    382                 as_switch(AS, irq->driver_as); \
    383         printf("Writing data to address: %p.\n", va); \
    384         memcpy_to_uspace(va, &val, sizeof(val)); \
    385 } while (0)
    386 
    387         as_t *current_as = AS;
    388366        size_t i;
    389367        for (i = 0; i < code->cmdcount; i++) {
    … …  
    444422                        }
    445423                        break;
    446                 case CMD_MEM_READ_8: {
    447                         uint8_t val;
    448                         CMD_MEM_READ(val);
    449                         break;
    450                         }
    451                 case CMD_MEM_READ_16: {
    452                         uint16_t val;
    453                         CMD_MEM_READ(val);
    454                         break;
    455                         }
    456                 case CMD_MEM_READ_32: {
    457                         uint32_t val;
    458                         CMD_MEM_READ(val);
    459                         printf("mem READ value: %x.\n", val);
    460                         break;
    461                         }
    462                 case CMD_MEM_WRITE_8: {
    463                         uint8_t val = code->cmds[i].value;
    464                         CMD_MEM_WRITE(val);
    465                         break;
    466                         }
    467                 case CMD_MEM_WRITE_16: {
    468                         uint16_t val = code->cmds[i].value;
    469                         CMD_MEM_WRITE(val);
    470                         break;
    471                         }
    472                 case CMD_MEM_WRITE_32: {
    473                         uint32_t val = code->cmds[i].value;
    474                         CMD_MEM_WRITE(val);
    475                         break;
    476                         }
    477                 case CMD_MEM_WRITE_A_8:
    478                         if (srcarg) {
    479                                 uint8_t val = scratch[srcarg];
    480                                 CMD_MEM_WRITE(val);
    481                         }
    482                         break;
    483                 case CMD_MEM_WRITE_A_16:
    484                         if (srcarg) {
    485                                 uint16_t val = scratch[srcarg];
    486                                 CMD_MEM_WRITE(val);
    487                         }
    488                         break;
    489                 case CMD_MEM_WRITE_A_32:
    490                         if (srcarg) {
    491                                 uint32_t val = scratch[srcarg];
    492                                 CMD_MEM_WRITE(val);
    493                         }
    494                         break;
    495424                case CMD_BTEST:
    496425                        if ((srcarg) && (dstarg)) {
    … …  
    506435                        break;
    507436                case CMD_ACCEPT:
    508                         if (AS != current_as)
    509                                 as_switch(AS, current_as);
    510437                        return IRQ_ACCEPT;
    511438                case CMD_DECLINE:
    512439                default:
    513                         if (AS != current_as)
    514                                 as_switch(AS, current_as);
    515440                        return IRQ_DECLINE;
    516441                }
    517442        }
    518         if (AS != current_as)
    519                 as_switch(AS, current_as);
    520443       
    521444        return IRQ_DECLINE;

  • uspace/drv/ehci-hcd/ehci-hcd.ma

    r45a2688 r5f7b75a  
    2210 pci/ven=1002&dev=4386
    3310 pci/ven=1002&dev=4396
    4 10 pci/ven=1002&dev=4373
    5410 pci/ven=1022&dev=7463
    6510 pci/ven=1022&dev=7808

  • uspace/drv/ehci-hcd/pci.c

    r45a2688 r5f7b75a  
    186186        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) to read PCI config space.\n",
    187187            ret);
    188         usb_log_info("Register space BAR at %p:%" PRIxn ".\n",
    189             (void *) address, value);
     188        usb_log_info("Register space BAR at %p:%" PRIxn ".\n", (void *) address, value);
    190189
    191190        /* clear lower byte, it's not part of the BASE address */

  • uspace/drv/ohci/hc.c

    r45a2688 r5f7b75a  
    4545#include "hcd_endpoint.h"
    4646
    47 #define OHCI_USED_INTERRUPTS \
    48     (I_SO | I_WDH | I_UE | I_RHSC)
    4947static int interrupt_emulator(hc_t *instance);
    5048static void hc_gain_control(hc_t *instance);
    … …  
    287285{
    288286        assert(instance);
     287        if ((status & ~IS_SF) == 0) /* ignore sof status */
     288                return;
     289        if (status & IS_RHSC)
     290                rh_interrupt(&instance->rh);
     291
    289292        usb_log_debug("OHCI interrupt: %x.\n", status);
    290         if ((status & ~I_SF) == 0) /* ignore sof status */
    291                 return;
    292         if (status & I_RHSC)
    293                 rh_interrupt(&instance->rh);
    294 
    295 
    296         if (status & I_WDH) {
     293
     294        if (status & IS_WDH) {
    297295                fibril_mutex_lock(&instance->guard);
    298296                usb_log_debug2("HCCA: %p-%#" PRIx32 " (%p).\n", instance->hcca,
    … …  
    334332{
    335333        assert(instance);
    336         usb_log_debug("Requesting OHCI control.\n");
    337334        /* Turn off legacy emulation */
    338335        volatile uint32_t *ohci_emulation_reg =
    … …  
    340337        usb_log_debug("OHCI legacy register %p: %x.\n",
    341338                ohci_emulation_reg, *ohci_emulation_reg);
    342         *ohci_emulation_reg &= ~0x1;
     339        *ohci_emulation_reg = 0;
    343340
    344341        /* Interrupt routing enabled => smm driver is active */
    … …  
    424421            instance->registers->control);
    425422
    426         /* Enable interrupts */
    427         instance->registers->interrupt_enable = OHCI_USED_INTERRUPTS;
     423        /* Disable interrupts */
     424        instance->registers->interrupt_disable = I_SF | I_OC;
     425        usb_log_debug2("Disabling interrupts: %x.\n",
     426            instance->registers->interrupt_disable);
     427        instance->registers->interrupt_disable = I_MI;
    428428        usb_log_debug2("Enabled interrupts: %x.\n",
    429429            instance->registers->interrupt_enable);
    430         instance->registers->interrupt_enable = I_MI;
    431430
    432431        /* Set periodic start to 90% */
    … …  
    493492            instance->lists[USB_TRANSFER_INTERRUPT].list_head_pa);
    494493
    495         /* Init interrupt code */
    496         instance->interrupt_code.cmds = instance->interrupt_commands;
    497         {
    498                 /* Read status register */
    499                 instance->interrupt_commands[0].cmd = CMD_MEM_READ_32;
    500                 instance->interrupt_commands[0].dstarg = 1;
    501                 instance->interrupt_commands[0].addr =
    502                     (void*)&instance->registers->interrupt_status;
    503 
    504                 /* Test whether we are the interrupt cause */
    505                 instance->interrupt_commands[1].cmd = CMD_BTEST;
    506                 instance->interrupt_commands[1].value =
    507                     OHCI_USED_INTERRUPTS;
    508                 instance->interrupt_commands[1].srcarg = 1;
    509                 instance->interrupt_commands[1].dstarg = 2;
    510 
    511                 /* Predicate cleaning and accepting */
    512                 instance->interrupt_commands[2].cmd = CMD_PREDICATE;
    513                 instance->interrupt_commands[2].value = 2;
    514                 instance->interrupt_commands[2].srcarg = 2;
    515 
    516                 /* Write clean status register */
    517                 instance->interrupt_commands[3].cmd = CMD_MEM_WRITE_A_32;
    518                 instance->interrupt_commands[3].srcarg = 1;
    519                 instance->interrupt_commands[3].addr =
    520                     (void*)&instance->registers->interrupt_status;
    521 
    522                 /* Accept interrupt */
    523                 instance->interrupt_commands[4].cmd = CMD_ACCEPT;
    524 
    525                 instance->interrupt_code.cmdcount = OHCI_NEEDED_IRQ_COMMANDS;
    526         }
    527 
    528494        return EOK;
    529495}

  • uspace/drv/ohci/hc.h

    r45a2688 r5f7b75a  
    5151#include "hw_struct/hcca.h"
    5252
    53 #define OHCI_NEEDED_IRQ_COMMANDS 5
    54 
    5553typedef struct hc {
    5654        ohci_regs_t *registers;
    … …  
    6765        fid_t interrupt_emulator;
    6866        fibril_mutex_t guard;
    69 
    70         /** Code to be executed in kernel interrupt handler */
    71         irq_code_t interrupt_code;
    72 
    73         /** Commands that form interrupt code */
    74         irq_cmd_t interrupt_commands[OHCI_NEEDED_IRQ_COMMANDS];
    7567} hc_t;
    7668

  • uspace/drv/ohci/ohci.c

    r45a2688 r5f7b75a  
    202202
    203203        /* It does no harm if we register this on polling */
    204         ret = register_interrupt_handler(device, irq, irq_handler,
    205             &instance->hc.interrupt_code);
     204        ret = register_interrupt_handler(device, irq, irq_handler, NULL);
    206205        CHECK_RET_FINI_RETURN(ret,
    207206            "Failed(%d) to register interrupt handler.\n", ret);

  • uspace/drv/ohci/ohci.ma

    r45a2688 r5f7b75a  
    1110 pci/ven=106b&dev=003f
    2210 pci/ven=10de&dev=0aa5
    3 
    4 10 pci/ven=1002&dev=4374
    5 10 pci/ven=1002&dev=4375
    6 
    7 10 pci/ven=1002&dev=4387
    8 10 pci/ven=1002&dev=4388
    9 10 pci/ven=1002&dev=4389
    10 10 pci/ven=1002&dev=438a
    11 10 pci/ven=1002&dev=438b
     310 pci/ven=10de&dev=0aa5

  • uspace/drv/ohci/ohci_regs.h

    r45a2688 r5f7b75a  
    7272#define CS_SOC_SHIFT (16)
    7373
    74         /** Interupt enable/disable/status,
    75          * reads give the same value,
    76          * writing causes enable/disable,
    77          * status is write-clean (writing 1 clears the bit*/
    7874        volatile uint32_t interrupt_status;
     75#define IS_SO   (1 << 0)  /* Scheduling overrun */
     76#define IS_WDH  (1 << 1)  /* Write-back done head */
     77#define IS_SF   (1 << 2)  /* Start of frame */
     78#define IS_RD   (1 << 3)  /* Resume detected */
     79#define IS_UE   (1 << 4)  /* Unrecoverable error */
     80#define IS_FNO  (1 << 5)  /* Frame number overflow */
     81#define IS_RHSC (1 << 6)  /* Root hub status change */
     82#define IS_OC   (1 << 30) /* Ownership change */
     83
     84        /** Interupt enable/disable, reads give the same value, writing causes
     85         * enable/disable */
    7986        volatile uint32_t interrupt_enable;
    8087        volatile uint32_t interrupt_disable;

  • uspace/drv/ohci/pci.c

    r45a2688 r5f7b75a  
    4646
    4747#include "pci.h"
     48
     49#define PAGE_SIZE_MASK 0xfffff000
     50
     51#define HCC_PARAMS_OFFSET 0x8
     52#define HCC_PARAMS_EECP_MASK 0xff
     53#define HCC_PARAMS_EECP_OFFSET 8
     54
     55#define CMD_OFFSET 0x0
     56#define CONFIGFLAG_OFFSET 0x40
     57
     58#define USBCMD_RUN 1
     59
     60#define USBLEGSUP_OFFSET 0
     61#define USBLEGSUP_BIOS_CONTROL (1 << 16)
     62#define USBLEGSUP_OS_CONTROL (1 << 24)
     63#define USBLEGCTLSTS_OFFSET 4
     64
     65#define DEFAULT_WAIT 10000
     66#define WAIT_STEP 10
    4867
    4968/** Get address of registers and IRQ for given device.
    … …  
    127146int pci_enable_interrupts(ddf_dev_t *device)
    128147{
     148        return ENOTSUP;
    129149        int parent_phone =
    130150            devman_parent_device_connect(device->handle, IPC_FLAG_BLOCKING);

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

    r45a2688 r5f7b75a  
    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

    r45a2688 r5f7b75a  
    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}

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

    r45a2688 r5f7b75a  
    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;
    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

    r45a2688 r5f7b75a  
    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

    r45a2688 r5f7b75a  
    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_mouse[] = {
    49         {USB_HIDUT_PAGE_GENERIC_DESKTOP, USB_HIDUT_USAGE_GENERIC_DESKTOP_MOUSE},
    50         {USB_HIDUT_PAGE_GENERIC_DESKTOP,
    51          USB_HIDUT_USAGE_GENERIC_DESKTOP_POINTER},
    52         {0, 0}
    53 };
    54 
    55 static usb_hid_subdriver_usage_t path_mouse2[] = {
    56         {USB_HIDUT_PAGE_GENERIC_DESKTOP, USB_HIDUT_USAGE_GENERIC_DESKTOP_X},
    5743        {0, 0}
    5844};
    … …  
    9379                }
    9480        },
    95         {
    96                 path_mouse,
    97                 -1,
    98                 USB_HID_PATH_COMPARE_COLLECTION_ONLY,
    99                 -1,
    100                 -1,
    101                 {
    102                         .init = usb_mouse_init,
    103                         .deinit = usb_mouse_deinit,
    104                         .poll = usb_mouse_polling_callback,
    105                         .poll_end = NULL
    106                 }
    107         },
    108         {
    109                 path_mouse2,
    110                 -1,
    111                 USB_HID_PATH_COMPARE_END
    112                 | USB_HID_PATH_COMPARE_USAGE_PAGE_ONLY,
    113                 -1,
    114                 -1,
    115                 {
    116                         .init = usb_mouse_init,
    117                         .deinit = usb_mouse_deinit,
    118                         .poll = usb_mouse_polling_callback,
    119                         .poll_end = NULL
    120                 }
    121         },
    12281        {NULL, -1, 0, -1, -1, {NULL, NULL, NULL, NULL}}
    12382};

  • uspace/drv/usbhid/usbhid.c

    r45a2688 r5f7b75a  
    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

    r45a2688 r5f7b75a  
    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/lib/usb/src/host/batch.c

    r45a2688 r5f7b75a  
    128128        memcpy(instance->buffer, instance->data_buffer, instance->buffer_size);
    129129
    130         usb_log_debug("Batch(%p) done (T%d.%d, %s %s in, %zuB): %s (%d).\n",
     130        usb_log_debug("Batch %p done (T%d.%d, %s %s in, %zuB): %s (%d).\n",
    131131            instance, instance->ep->address, instance->ep->endpoint,
    132132            usb_str_speed(instance->ep->speed),
    133133            usb_str_transfer_type_short(instance->ep->transfer_type),
    134             instance->transfered_size, str_error(instance->error),
    135             instance->error);
     134            instance->transfered_size, str_error(instance->error), instance->error);
    136135
    137136        instance->callback_in(instance->fun, instance->error,
    … …  
    148147        assert(instance->callback_out);
    149148
    150         usb_log_debug("Batch(%p) done (T%d.%d, %s %s out): %s (%d).\n",
     149        usb_log_debug("Batch %p done (T%d.%d, %s %s out): %s (%d).\n",
    151150            instance, instance->ep->address, instance->ep->endpoint,
    152151            usb_str_speed(instance->ep->speed),
Note: See TracChangeset for help on using the changeset viewer.