Changes in / [d38d830:beee81a] in mainline


Ignore:
Files:
24 edited

Legend:

Unmodified
Added
Removed

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

    rd38d830 rbeee81a  
    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

    rd38d830 rbeee81a  
    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

    rd38d830 rbeee81a  
    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

    rd38d830 rbeee81a  
    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

    rd38d830 rbeee81a  
    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

    rd38d830 rbeee81a  
    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

    rd38d830 rbeee81a  
    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

    rd38d830 rbeee81a  
    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

    rd38d830 rbeee81a  
    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

    rd38d830 rbeee81a  
    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

    rd38d830 rbeee81a  
    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

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

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

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

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

    rd38d830 rbeee81a  
    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

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

  • uspace/drv/usbhid/usbhid.c

    rd38d830 rbeee81a  
    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

    rd38d830 rbeee81a  
    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/include/usb/classes/hiddescriptor.h

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

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

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

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

    rd38d830 rbeee81a  
    165165        /** */ 
    166166        link_t link;
    167 
    168         int in_delimiter;
    169167} usb_hid_report_item_t;
    170168

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

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

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

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

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

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

  • uspace/lib/usb/src/host/batch.c

    rd38d830 rbeee81a  
    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.