Changes in / [70922c2:3d4750f] in mainline


Ignore:
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • boot/arch/ppc32/Makefile.inc

    r70922c2 r3d4750f  
    4343
    4444RD_DRVS += \
    45         infrastructure/rootmac \
    46         bus/pci/pciintel
     45        infrastructure/rootmac
    4746
    4847SOURCES = \

  • uspace/Makefile

    r70922c2 r3d4750f  
    165165        DIRS += \
    166166                drv/infrastructure/rootmac \
    167                 drv/bus/pci/pciintel \
    168167                srv/hw/bus/cuda_adb
    169168endif

  • uspace/drv/bus/pci/pciintel/pci.c

    r70922c2 r3d4750f  
    3838
    3939#include <assert.h>
    40 #include <byteorder.h>
    4140#include <stdio.h>
    4241#include <errno.h>
    … …  
    232231        void *addr = bus->conf_data_port + (reg & 3);
    233232       
    234         pio_write_32(bus->conf_addr_port, host2uint32_t_le(conf_addr));
     233        pio_write_32(bus->conf_addr_port, conf_addr);
    235234       
    236235        switch (len) {
    237236        case 1:
    238                 /* No endianness change for 1 byte */
    239237                buf[0] = pio_read_8(addr);
    240238                break;
    241239        case 2:
    242                 ((uint16_t *) buf)[0] = uint16_t_le2host(pio_read_16(addr));
     240                ((uint16_t *) buf)[0] = pio_read_16(addr);
    243241                break;
    244242        case 4:
    245                 ((uint32_t *) buf)[0] = uint32_t_le2host(pio_read_32(addr));
     243                ((uint32_t *) buf)[0] = pio_read_32(addr);
    246244                break;
    247245        }
    … …  
    256254        fibril_mutex_lock(&bus->conf_mutex);
    257255       
    258         const uint32_t conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
     256        uint32_t conf_addr;
     257        conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
    259258        void *addr = bus->conf_data_port + (reg & 3);
    260259       
    261         pio_write_32(bus->conf_addr_port, host2uint32_t_le(conf_addr));
     260        pio_write_32(bus->conf_addr_port, conf_addr);
    262261       
    263262        switch (len) {
    264263        case 1:
    265                 /* No endianness change for 1 byte */
    266264                pio_write_8(addr, buf[0]);
    267265                break;
    268266        case 2:
    269                 pio_write_16(addr, host2uint16_t_le(((uint16_t *) buf)[0]));
     267                pio_write_16(addr, ((uint16_t *) buf)[0]);
    270268                break;
    271269        case 4:
    272                 pio_write_32(addr, host2uint32_t_le(((uint32_t *) buf)[0]));
     270                pio_write_32(addr, ((uint32_t *) buf)[0]);
    273271                break;
    274272        }
    … …  
    652650        got_res = true;
    653651       
    654        
    655         assert(hw_resources.count > 1);
    656         assert(hw_resources.resources[0].type == IO_RANGE);
    657         assert(hw_resources.resources[0].res.io_range.size >= 4);
    658        
    659         assert(hw_resources.resources[1].type == IO_RANGE);
    660         assert(hw_resources.resources[1].res.io_range.size >= 4);
    661        
    662652        ddf_msg(LVL_DEBUG, "conf_addr = %" PRIx64 ".",
    663653            hw_resources.resources[0].res.io_range.address);
    664         ddf_msg(LVL_DEBUG, "data_addr = %" PRIx64 ".",
    665             hw_resources.resources[1].res.io_range.address);
     654       
     655        assert(hw_resources.count > 0);
     656        assert(hw_resources.resources[0].type == IO_RANGE);
     657        assert(hw_resources.resources[0].res.io_range.size == 8);
    666658       
    667659        bus->conf_io_addr =
    668660            (uint32_t) hw_resources.resources[0].res.io_range.address;
    669         bus->conf_io_data =
    670             (uint32_t) hw_resources.resources[1].res.io_range.address;
    671        
    672         if (pio_enable((void *)(uintptr_t)bus->conf_io_addr, 4,
     661       
     662        if (pio_enable((void *)(uintptr_t)bus->conf_io_addr, 8,
    673663            &bus->conf_addr_port)) {
    674664                ddf_msg(LVL_ERROR, "Failed to enable configuration ports.");
    … …  
    676666                goto fail;
    677667        }
    678         if (pio_enable((void *)(uintptr_t)bus->conf_io_data, 4,
    679             &bus->conf_data_port)) {
    680                 ddf_msg(LVL_ERROR, "Failed to enable configuration ports.");
    681                 rc = EADDRNOTAVAIL;
    682                 goto fail;
    683         }
     668        bus->conf_data_port = (char *) bus->conf_addr_port + 4;
    684669       
    685670        /* Make the bus device more visible. It has no use yet. */

  • uspace/drv/bus/pci/pciintel/pci.h

    r70922c2 r3d4750f  
    4646        ddf_dev_t *dnode;
    4747        uint32_t conf_io_addr;
    48         uint32_t conf_io_data;
    4948        void *conf_data_port;
    5049        void *conf_addr_port;

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

    r70922c2 r3d4750f  
    7171#include "../usbhid.h"
    7272
    73 static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
    74 static ddf_dev_ops_t kbdops = { .default_handler = default_connection_handler };
    7573/*----------------------------------------------------------------------------*/
    7674
    … …  
    189187                        break;
    190188                }
    191                 if (kbd_dev->client_sess == NULL) {
    192                         kbd_dev->client_sess = sess;
     189                if (kbd_dev->console_sess == NULL) {
     190                        kbd_dev->console_sess = sess;
    193191                        usb_log_debug("%s: OK\n", __FUNCTION__);
    194192                        async_answer_0(icallid, EOK);
    … …  
    294292{
    295293        usb_log_debug2("Sending kbdev event %d/%d to the console\n", type, key);
    296         if (kbd_dev->client_sess == NULL) {
     294        if (kbd_dev->console_sess == NULL) {
    297295                usb_log_warning(
    298296                    "Connection to console not ready, key discarded.\n");
    … …  
    300298        }
    301299
    302         async_exch_t *exch = async_exchange_begin(kbd_dev->client_sess);
     300        async_exch_t *exch = async_exchange_begin(kbd_dev->console_sess);
    303301        if (exch != NULL) {
    304302                async_msg_2(exch, KBDEV_EVENT, type, key);
    … …  
    501499        /* Store the initialized HID device and HID ops
    502500         * to the DDF function. */
    503         fun->ops = &kbdops;
     501        fun->ops = &kbd_dev->ops;
    504502        fun->driver_data = kbd_dev;
    505503
    … …  
    578576        fibril_mutex_initialize(&kbd_dev->repeat_mtx);
    579577        kbd_dev->initialized = USB_KBD_STATUS_UNINITIALIZED;
     578        kbd_dev->ops.default_handler = default_connection_handler;
    580579
    581580        /* Store link to HID device */
    … …  
    738737
    739738        /* Hangup session to the console. */
    740         if (kbd_dev->client_sess)
    741                 async_hangup(kbd_dev->client_sess);
     739        if (kbd_dev->console_sess)
     740                async_hangup(kbd_dev->console_sess);
    742741
    743742        //assert(!fibril_mutex_is_locked((*kbd_dev)->repeat_mtx));

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

    r70922c2 r3d4750f  
    8282        unsigned lock_keys;
    8383
    84         /** IPC session to client (for sending key events). */
    85         async_sess_t *client_sess;
     84        /** IPC session to the console device (for sending key events). */
     85        async_sess_t *console_sess;
     86
     87        /** @todo What is this actually? */
     88        ddf_dev_ops_t ops;
    8689
    8790        /** Information for auto-repeat of keys. */

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

    r70922c2 r3d4750f  
    5454#define NAME "mouse"
    5555
    56 static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
    57 
    58 static ddf_dev_ops_t ops = { .default_handler = default_connection_handler };
    59 
    60 /*----------------------------------------------------------------------------*/
     56/*----------------------------------------------------------------------------*/
     57
    6158const usb_endpoint_description_t usb_hid_mouse_poll_endpoint_description = {
    6259        .transfer_type = USB_TRANSFER_INTERRUPT,
    … …  
    224221                assert(index < mouse_dev->buttons_count);
    225222
    226                 if (mouse_dev->buttons[index] != field->value) {
     223                if (mouse_dev->buttons[index] == 0 && field->value != 0) {
    227224                        async_exch_t *exch =
    228225                            async_exchange_begin(mouse_dev->mouse_sess);
    229226                        if (exch != NULL) {
    230227                                async_req_2_0(exch, MOUSEEV_BUTTON_EVENT,
    231                                     field->usage, (field->value != 0) ? 1 : 0);
     228                                    field->usage, 1);
     229                                async_exchange_end(exch);
     230                                mouse_dev->buttons[index] = field->value;
     231                        }
     232
     233                } else if (mouse_dev->buttons[index] != 0 && field->value == 0) {
     234                        async_exch_t *exch =
     235                            async_exchange_begin(mouse_dev->mouse_sess);
     236                        if (exch != NULL) {
     237                                async_req_2_0(exch, MOUSEEV_BUTTON_EVENT,
     238                                    field->usage, 0);
    232239                                async_exchange_end(exch);
    233240                                mouse_dev->buttons[index] = field->value;
    … …  
    272279        }
    273280
    274         fun->ops = &ops;
     281        fun->ops = &mouse->ops;
    275282        fun->driver_data = mouse;
    276283
    … …  
    295302        }
    296303        mouse->mouse_fun = fun;
     304
    297305        return EOK;
    298306}
    … …  
    371379        }
    372380
     381        // set handler for incoming calls
     382        mouse_dev->ops.default_handler = default_connection_handler;
     383
    373384        // TODO: how to know if the device supports the request???
    374385        usbhid_req_set_idle(&hid_dev->usb_dev->ctrl_pipe,

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

    r70922c2 r3d4750f  
    4646/** Container for USB mouse device. */
    4747typedef struct {
    48         /** IPC session to consumer. */
     48        /** IPC session to console (consumer). */
    4949        async_sess_t *mouse_sess;
    5050
    … …  
    5353        size_t buttons_count;
    5454
     55        ddf_dev_ops_t ops;
    5556        /* DDF mouse function */
    5657        ddf_fun_t *mouse_fun;

  • uspace/drv/infrastructure/rootmac/rootmac.c

    r70922c2 r3d4750f  
    5252} rootmac_fun_t;
    5353
    54 static hw_resource_t pci_conf_regs[] = {
    55         {
    56                 .type = IO_RANGE,
    57                 .res.io_range = {
    58                         .address = 0xfec00000,
    59                         .size = 4,
    60                         .endianness = LITTLE_ENDIAN
    61                 }
    62         },
    63         {
    64                 .type = IO_RANGE,
    65                 .res.io_range = {
    66                         .address = 0xfee00000,
    67                         .size = 4,
    68                         .endianness = LITTLE_ENDIAN
    69                 }
     54static hw_resource_t pci_conf_regs = {
     55        .type = IO_RANGE,
     56        .res.io_range = {
     57                .address = 0xCF8,
     58                .size = 8,
     59                .endianness = LITTLE_ENDIAN
    7060        }
    7161};
    … …  
    7363static rootmac_fun_t pci_data = {
    7464        .hw_resources = {
    75                 2,
    76                 pci_conf_regs
     65                1,
     66                &pci_conf_regs
    7767        }
    7868};
    … …  
    138128{
    139129        /* Register functions */
    140         if (!rootmac_add_fun(dev, "pci0", "intel_pci", &pci_data))
     130        if (!rootmac_add_fun(dev, "pci0", "pangea_pci", &pci_data))
    141131                ddf_msg(LVL_ERROR, "Failed to add functions for Mac platform.");
    142132       

  • uspace/drv/infrastructure/rootpc/rootpc.c

    r70922c2 r3d4750f  
    7777};
    7878
    79 static hw_resource_t pci_conf_regs[] = {
    80         {
    81                 .type = IO_RANGE,
    82                 .res.io_range = {
    83                         .address = 0xCF8,
    84                         .size = 4,
    85                         .endianness = LITTLE_ENDIAN
    86                 }
    87         },
    88         {
    89                 .type = IO_RANGE,
    90                 .res.io_range = {
    91                         .address = 0xCFC,
    92                         .size = 4,
    93                         .endianness = LITTLE_ENDIAN
    94                 }
     79static hw_resource_t pci_conf_regs = {
     80        .type = IO_RANGE,
     81        .res.io_range = {
     82                .address = 0xCF8,
     83                .size = 8,
     84                .endianness = LITTLE_ENDIAN
    9585        }
    9686};
    … …  
    9888static rootpc_fun_t pci_data = {
    9989        .hw_resources = {
    100                 sizeof(pci_conf_regs)/sizeof(pci_conf_regs[0]),
    101                 pci_conf_regs
     90                1,
     91                &pci_conf_regs
    10292        }
    10393};

  • uspace/lib/drv/generic/remote_usb.c

    r70922c2 r3d4750f  
    5656{
    5757        if (!exch)
    58                 return EBADMEM;
     58                return EINVAL;
    5959        sysarg_t addr;
    6060        const int ret = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
    … …  
    7575{
    7676        if (!exch)
    77                 return EBADMEM;
     77                return EINVAL;
    7878        sysarg_t iface_no;
    7979        const int ret = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
    … …  
    9292{
    9393        if (!exch)
    94                 return EBADMEM;
     94                return EINVAL;
    9595        devman_handle_t h;
    9696        const int ret = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),

  • uspace/lib/drv/generic/remote_usbhc.c

    r70922c2 r3d4750f  
    165165{
    166166        if (!exch || !address)
    167                 return EBADMEM;
     167                return EINVAL;
    168168        sysarg_t new_address;
    169169        const int ret = async_req_4_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    … …  
    178178{
    179179        if (!exch)
    180                 return EBADMEM;
     180                return EINVAL;
    181181        return async_req_3_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    182182            IPC_M_USBHC_BIND_ADDRESS, address, handle);
    … …  
    187187{
    188188        if (!exch)
    189                 return EBADMEM;
     189                return EINVAL;
    190190        sysarg_t h;
    191191        const int ret = async_req_2_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    … …  
    199199{
    200200        if (!exch)
    201                 return EBADMEM;
     201                return EINVAL;
    202202        return async_req_2_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    203203            IPC_M_USBHC_RELEASE_ADDRESS, address);
    … …  
    209209{
    210210        if (!exch)
    211                 return EBADMEM;
     211                return EINVAL;
    212212        const usb_target_t target =
    213213            {{ .address = address, .endpoint = endpoint }};
    … …  
    225225{
    226226        if (!exch)
    227                 return EBADMEM;
     227                return EINVAL;
    228228        return async_req_4_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    229229            IPC_M_USBHC_UNREGISTER_ENDPOINT, address, endpoint, direction);
    … …  
    234234    size_t *rec_size)
    235235{
    236         if (!exch)
    237                 return EBADMEM;
    238 
    239236        if (size == 0 && setup == 0)
    240237                return EOK;
    241238
     239        if (!exch)
     240                return EINVAL;
    242241        const usb_target_t target =
    243242            {{ .address = address, .endpoint = endpoint }};
    … …  
    289288    usb_endpoint_t endpoint, uint64_t setup, const void *data, size_t size)
    290289{
    291         if (!exch)
    292                 return EBADMEM;
    293 
    294290        if (size == 0 && setup == 0)
    295291                return EOK;
    296292
     293        if (!exch)
     294                return EINVAL;
    297295        const usb_target_t target =
    298296            {{ .address = address, .endpoint = endpoint }};
Note: See TracChangeset for help on using the changeset viewer.