Changes in / [df29f24:5d1b3aa] in mainline


Ignore:
Files:
256 deleted
47 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    rdf29f24 r5d1b3aa  
    538538
    539539% Run devman on startup
    540 ! CONFIG_START_DEVMAN (y)
     540! CONFIG_START_DEVMAN (y/n)
    541541
    542542% Launch (devman) test drivers
    … …  
    563563% Line debugging information
    564564! [CONFIG_STRIP_BINARIES!=y] CONFIG_LINE_DEBUG (n/y)
    565 
    566 # USB settings
    567 
    568 % USB release build (less logging)
    569 ! CONFIG_USB_RELEASE_BUILD (y/n)
    570 
    571 % Start virtual USB host controller
    572 ! CONFIG_RUN_VIRTUAL_USB_HC (n/y)
    573 
    574 % Polling UHCI & OHCI (no interrupts)
    575 ! [PLATFORM=ia32|PLATFORM=amd64] CONFIG_USBHC_NO_INTERRUPTS (n/y)
    576 
    577 % Run devman in kconsole (not recommended)
    578 ! CONFIG_DEVMAN_EARLY_LAUNCH (n/y)

  • Makefile

    rdf29f24 r5d1b3aa  
    106106        $(MAKE) -C uspace clean
    107107        $(MAKE) -C boot clean
    108 
    109 -include Makefile.local

  • boot/Makefile.common

    rdf29f24 r5d1b3aa  
    142142        $(USPACE_PATH)/app/killall/killall \
    143143        $(USPACE_PATH)/app/mkfat/mkfat \
    144         $(USPACE_PATH)/app/lsusb/lsusb \
    145144        $(USPACE_PATH)/app/sbi/sbi \
    146145        $(USPACE_PATH)/app/redir/redir \
    … …  
    154153        $(USPACE_PATH)/app/ping/ping \
    155154        $(USPACE_PATH)/app/stats/stats \
     155        $(USPACE_PATH)/app/top/top \
    156156        $(USPACE_PATH)/app/sysinfo/sysinfo \
    157         $(USPACE_PATH)/app/top/top \
    158         $(USPACE_PATH)/app/usbinfo/usbinfo \
    159         $(USPACE_PATH)/app/vuhid/vuh \
    160         $(USPACE_PATH)/app/mkbd/mkbd \
    161157        $(USPACE_PATH)/app/websrv/websrv
    162158

  • boot/arch/amd64/Makefile.inc

    rdf29f24 r5d1b3aa  
    4242        pciintel \
    4343        isa \
    44         ns8250 \
    45         ehci-hcd \
    46         ohci \
    47         uhci-hcd \
    48         uhci-rhd \
    49         usbflbk \
    50         usbhub \
    51         usbhid \
    52         usbmast \
    53         usbmid \
    54         usbmouse \
    55         vhc
     44        ns8250
    5645
    5746RD_DRV_CFG += \

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

    rdf29f24 r5d1b3aa  
    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/include/mm/page.h

    rdf29f24 r5d1b3aa  
    3737
    3838#include <typedefs.h>
    39 #include <proc/task.h>
    4039#include <mm/as.h>
    4140#include <arch/mm/page.h>
    … …  
    6665extern uintptr_t hw_map(uintptr_t, size_t);
    6766
    68 extern sysarg_t sys_page_find_mapping(uintptr_t, uintptr_t *);
    69 
    7067#endif
    7168

  • kernel/generic/include/proc/thread.h

    rdf29f24 r5d1b3aa  
    258258extern sysarg_t sys_thread_get_id(thread_id_t *);
    259259extern sysarg_t sys_thread_usleep(uint32_t);
    260 extern sysarg_t sys_thread_udelay(uint32_t);
    261260
    262261#endif

  • kernel/generic/include/syscall/syscall.h

    rdf29f24 r5d1b3aa  
    4444        SYS_THREAD_GET_ID,
    4545        SYS_THREAD_USLEEP,
    46         SYS_THREAD_UDELAY,
    4746       
    4847        SYS_TASK_GET_ID,
    … …  
    6160        SYS_AS_AREA_DESTROY,
    6261        SYS_AS_GET_UNMAPPED_AREA,
    63        
    64         SYS_PAGE_FIND_MAPPING,
    6562       
    6663        SYS_IPC_CALL_SYNC_FAST,

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

    rdf29f24 r5d1b3aa  
    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         memcpy_from_uspace(&target, va, (sizeof(target))); \
    373         if (dstarg) \
    374                 scratch[dstarg] = target; \
    375 } while(0)
    376 
    377 #define CMD_MEM_WRITE(val) \
    378 do { \
    379         void *va = code->cmds[i].addr; \
    380         if (AS != irq->driver_as) \
    381                 as_switch(AS, irq->driver_as); \
    382         memcpy_to_uspace(va, &val, sizeof(val)); \
    383 } while (0)
    384 
    385         as_t *current_as = AS;
    386366        size_t i;
    387367        for (i = 0; i < code->cmdcount; i++) {
    … …  
    442422                        }
    443423                        break;
    444                 case CMD_MEM_READ_8: {
    445                         uint8_t val;
    446                         CMD_MEM_READ(val);
    447                         break;
    448                         }
    449                 case CMD_MEM_READ_16: {
    450                         uint16_t val;
    451                         CMD_MEM_READ(val);
    452                         break;
    453                         }
    454                 case CMD_MEM_READ_32: {
    455                         uint32_t val;
    456                         CMD_MEM_READ(val);
    457                         break;
    458                         }
    459                 case CMD_MEM_WRITE_8: {
    460                         uint8_t val = code->cmds[i].value;
    461                         CMD_MEM_WRITE(val);
    462                         break;
    463                         }
    464                 case CMD_MEM_WRITE_16: {
    465                         uint16_t val = code->cmds[i].value;
    466                         CMD_MEM_WRITE(val);
    467                         break;
    468                         }
    469                 case CMD_MEM_WRITE_32: {
    470                         uint32_t val = code->cmds[i].value;
    471                         CMD_MEM_WRITE(val);
    472                         break;
    473                         }
    474                 case CMD_MEM_WRITE_A_8:
    475                         if (srcarg) {
    476                                 uint8_t val = scratch[srcarg];
    477                                 CMD_MEM_WRITE(val);
    478                         }
    479                         break;
    480                 case CMD_MEM_WRITE_A_16:
    481                         if (srcarg) {
    482                                 uint16_t val = scratch[srcarg];
    483                                 CMD_MEM_WRITE(val);
    484                         }
    485                         break;
    486                 case CMD_MEM_WRITE_A_32:
    487                         if (srcarg) {
    488                                 uint32_t val = scratch[srcarg];
    489                                 CMD_MEM_WRITE(val);
    490                         }
    491                         break;
    492424                case CMD_BTEST:
    493425                        if ((srcarg) && (dstarg)) {
    … …  
    503435                        break;
    504436                case CMD_ACCEPT:
    505                         if (AS != current_as)
    506                                 as_switch(AS, current_as);
    507437                        return IRQ_ACCEPT;
    508438                case CMD_DECLINE:
    509439                default:
    510                         if (AS != current_as)
    511                                 as_switch(AS, current_as);
    512440                        return IRQ_DECLINE;
    513441                }
    514442        }
    515         if (AS != current_as)
    516                 as_switch(AS, current_as);
    517443       
    518444        return IRQ_DECLINE;

  • kernel/generic/src/mm/as.c

    rdf29f24 r5d1b3aa  
    19661966sysarg_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags)
    19671967{
    1968         if (as_area_create(AS, flags, size, address,
     1968        if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address,
    19691969            AS_AREA_ATTR_NONE, &anon_backend, NULL))
    19701970                return (sysarg_t) address;

  • kernel/generic/src/mm/page.c

    rdf29f24 r5d1b3aa  
    6060
    6161#include <mm/page.h>
    62 #include <genarch/mm/page_ht.h>
    63 #include <genarch/mm/page_pt.h>
    6462#include <arch/mm/page.h>
    6563#include <arch/mm/asid.h>
    … …  
    7270#include <debug.h>
    7371#include <arch.h>
    74 #include <syscall/copy.h>
    75 #include <errno.h>
    7672
    7773/** Virtual operations for page subsystem. */
    … …  
    176172}
    177173
    178 /** Syscall wrapper for getting mapping of a virtual page.
    179  *
    180  * @retval EOK Everything went find, @p uspace_frame and @p uspace_node
    181  *             contains correct values.
    182  * @retval ENOENT Virtual address has no mapping.
    183  */
    184 sysarg_t sys_page_find_mapping(uintptr_t virt_address,
    185     uintptr_t *uspace_frame)
    186 {
    187         mutex_lock(&AS->lock);
    188        
    189         pte_t *pte = page_mapping_find(AS, virt_address, true);
    190         if (!PTE_VALID(pte) || !PTE_PRESENT(pte)) {
    191                 mutex_unlock(&AS->lock);
    192                
    193                 return (sysarg_t) ENOENT;
    194         }
    195        
    196         uintptr_t phys_address = PTE_GET_FRAME(pte);
    197        
    198         mutex_unlock(&AS->lock);
    199        
    200         int rc = copy_to_uspace(uspace_frame,
    201             &phys_address, sizeof(phys_address));
    202         if (rc != EOK) {
    203                 return (sysarg_t) rc;
    204         }
    205        
    206         return EOK;
    207 }
    208 
    209174/** @}
    210175 */

  • kernel/generic/src/proc/thread.c

    rdf29f24 r5d1b3aa  
    912912}
    913913
    914 sysarg_t sys_thread_udelay(uint32_t usec)
    915 {
    916         asm_delay_loop(usec * CPU->delay_loop_const);
    917         return 0;
    918 }
    919 
    920914/** @}
    921915 */

  • kernel/generic/src/syscall/syscall.c

    rdf29f24 r5d1b3aa  
    4141#include <proc/program.h>
    4242#include <mm/as.h>
    43 #include <mm/page.h>
    4443#include <print.h>
    4544#include <arch.h>
    … …  
    127126        (syshandler_t) sys_thread_get_id,
    128127        (syshandler_t) sys_thread_usleep,
    129         (syshandler_t) sys_thread_udelay,
    130128       
    131129        (syshandler_t) sys_task_get_id,
    … …  
    146144        (syshandler_t) sys_as_area_destroy,
    147145        (syshandler_t) sys_as_get_unmapped_area,
    148        
    149         /* Page mapping related syscalls. */
    150         (syshandler_t) sys_page_find_mapping,
    151146       
    152147        /* IPC related syscalls. */

  • uspace/Makefile

    rdf29f24 r5d1b3aa  
    4141        app/killall \
    4242        app/klog \
    43         app/lsusb \
    4443        app/mkfat \
    4544        app/redir \
    … …  
    5150        app/trace \
    5251        app/top \
    53         app/usbinfo \
    54         app/vuhid \
    5552        app/netecho \
    5653        app/nettest1 \
    … …  
    5956        app/websrv \
    6057        app/sysinfo \
    61         app/mkbd \
    6258        srv/clip \
    6359        srv/devmap \
    … …  
    118114                drv/ns8250 \
    119115                srv/hw/irc/apic \
    120                 srv/hw/irc/i8259 \
    121                 drv/ehci-hcd \
    122                 drv/ohci \
    123                 drv/uhci-hcd \
    124                 drv/uhci-rhd \
    125                 drv/usbflbk \
    126                 drv/usbhid \
    127                 drv/usbhub \
    128                 drv/usbmast \
    129                 drv/usbmid \
    130                 drv/usbmouse \
    131                 drv/vhc
     116                srv/hw/irc/i8259
    132117endif
    133118
    … …  
    139124                drv/ns8250 \
    140125                srv/hw/irc/apic \
    141                 srv/hw/irc/i8259 \
    142                 drv/ehci-hcd \
    143                 drv/ohci \
    144                 drv/uhci-hcd \
    145                 drv/uhci-rhd \
    146                 drv/usbflbk \
    147                 drv/usbhid \
    148                 drv/usbhub \
    149                 drv/usbmast \
    150                 drv/usbmid \
    151                 drv/usbmouse \
    152                 drv/vhc
     126                srv/hw/irc/i8259
    153127endif
    154128
    … …  
    176150        lib/packet \
    177151        lib/net
    178 
    179 ifeq ($(UARCH),amd64)
    180         LIBS += lib/usb
    181         LIBS += lib/usbhost
    182         LIBS += lib/usbdev
    183         LIBS += lib/usbhid
    184         LIBS += lib/usbvirt
    185 endif
    186 
    187 ifeq ($(UARCH),ia32)
    188         LIBS += lib/usb
    189         LIBS += lib/usbhost
    190         LIBS += lib/usbdev
    191         LIBS += lib/usbhid
    192         LIBS += lib/usbvirt
    193 endif
    194152
    195153LIBC_BUILD = $(addsuffix .build,$(LIBC))

  • uspace/Makefile.common

    rdf29f24 r5d1b3aa  
    108108LIBCLUI_PREFIX = $(LIB_PREFIX)/clui
    109109
    110 
    111 LIBUSB_PREFIX = $(LIB_PREFIX)/usb
    112 LIBUSBHOST_PREFIX = $(LIB_PREFIX)/usbhost
    113 LIBUSBDEV_PREFIX = $(LIB_PREFIX)/usbdev
    114 LIBUSBHID_PREFIX = $(LIB_PREFIX)/usbhid
    115 LIBUSBVIRT_PREFIX = $(LIB_PREFIX)/usbvirt
    116110LIBDRV_PREFIX = $(LIB_PREFIX)/drv
    117111LIBPACKET_PREFIX = $(LIB_PREFIX)/packet
    … …  
    131125        endif
    132126endif
    133 # Build static whenever we use libusb because that library uses
    134 # thread local variables
    135 ifneq ($(findstring usb, $(LIBS)),)
    136         STATIC_BUILD = y
    137 endif
    138127
    139128ifeq ($(STATIC_BUILD), y)

  • uspace/app/init/init.c

    rdf29f24 r5d1b3aa  
    272272        mount_tmpfs();
    273273       
     274#ifdef CONFIG_START_DEVMAN
     275        spawn("/srv/devman");
     276#endif
    274277        spawn("/srv/apic");
    275278        spawn("/srv/i8259");
    … …  
    313316        getterm("term/vc5", "/app/bdsh", false);
    314317        getterm("term/vc6", "/app/klog", false);
    315 
    316 #ifdef CONFIG_START_DEVMAN
    317 
    318 #ifdef CONFIG_DEVMAN_EARLY_LAUNCH
    319         spawn("/srv/devman");
    320 #else
    321         getterm("term/vc7", "/srv/devman", false);
    322 #endif
    323 
    324 #endif
    325 
     318       
    326319        return 0;
    327320}

  • uspace/app/tester/Makefile

    rdf29f24 r5d1b3aa  
    5151        mm/malloc1.c \
    5252        mm/malloc2.c \
    53         mm/mapping1.c \
    5453        mm/malloc3.c \
    5554        devs/devman1.c \

  • uspace/app/tester/tester.c

    rdf29f24 r5d1b3aa  
    6464#include "mm/malloc2.def"
    6565#include "mm/malloc3.def"
    66 #include "mm/mapping1.def"
    6766#include "hw/serial/serial1.def"
    6867#include "hw/misc/virtchar1.def"

  • uspace/app/tester/tester.h

    rdf29f24 r5d1b3aa  
    9797extern const char *test_malloc2(void);
    9898extern const char *test_malloc3(void);
    99 extern const char *test_mapping1(void);
    10099extern const char *test_serial1(void);
    101100extern const char *test_virtchar1(void);

  • uspace/doc/doxygroups.h

    rdf29f24 r5d1b3aa  
    150150         * @endcond
    151151         */
    152 
     152       
    153153/**
    154154 * @defgroup emul Emulation Libraries
    … …  
    165165         * @ingroup emul
    166166         */
    167 
    168 /**
    169  * @defgroup usb USB
    170  * @ingroup uspace
    171  * @brief USB support for HelenOS.
    172  */
    173         /**
    174          * @defgroup libusb Base USB library
    175          * @ingroup usb
    176          * @brief Common definitions for any driver or application
    177          * dealing with USB.
    178          */
    179 
    180         /**
    181          * @defgroup libusbdev USB library for device drivers
    182          * @ingroup usb
    183          * @brief Library for writing drivers of endpoint devices (functions).
    184          */
    185 
    186         /**
    187          * @defgroup libusbhost USB library for host controller drivers
    188          * @ingroup usb
    189          * @brief Library for writing host controller drivers.
    190          */
    191 
    192         /**
    193          * @defgroup libusbhid USB library for HID devices
    194          * @ingroup usb
    195          * @brief Library for writing USB HID drivers.
    196          */
    197 
    198         /**
    199          * @defgroup usbvirt USB virtualization
    200          * @ingroup usb
    201          * @brief Support for virtual USB devices.
    202          */
    203 
    204                 /**
    205                  * @defgroup libusbvirt USB virtualization library
    206                  * @ingroup usbvirt
    207                  * @brief Library for creating virtual USB devices.
    208                  */
    209 
    210                 /**
    211                  * @defgroup drvusbvhc Virtual USB host controller
    212                  * @ingroup usbvirt
    213                  * @brief Driver simulating work of USB host controller.
    214                  */
    215 
    216                 /**
    217                  * @defgroup usbvirthub Virtual USB hub
    218                  * @ingroup usbvirt
    219                  * @brief Extra virtual USB hub for virtual host controller.
    220                  * @details
    221                  * Some of the sources are shared with virtual host controller,
    222                  * see @ref drvusbvhc for the rest of the files.
    223                  */
    224 
    225                 /**
    226                  * @defgroup usbvirtkbd Virtual USB keybaord
    227                  * @ingroup usbvirt
    228                  * @brief Virtual USB keyboard for virtual host controller.
    229                  */
    230 
    231         /**
    232          * @defgroup usbinfo USB info application
    233          * @ingroup usb
    234          * @brief Application for querying USB devices.
    235          * @details
    236          * The intended usage of this application is to query new USB devices
    237          * for their descriptors etc. to simplify driver writing.
    238          */
    239 
    240         /**
    241          * @defgroup lsusb HelenOS version of lsusb command
    242          * @ingroup usb
    243          * @brief Application for listing USB host controllers.
    244          * @details
    245          * List all found host controllers.
    246          */
    247 
    248         /**
    249          * @defgroup drvusbmid USB multi interface device driver
    250          * @ingroup usb
    251          * @brief USB multi interface device driver
    252          * @details
    253          * This driver serves as a mini hub (or bus) driver for devices
    254          * that have the class defined at interface level (those devices
    255          * usually have several interfaces).
    256          *
    257          * The term multi interface device driver (MID) was borrowed
    258          * Solaris operating system.
    259          */
    260 
    261         /**
    262          * @defgroup drvusbhub USB hub driver
    263          * @ingroup usb
    264          * @brief USB hub driver.
    265          */
    266 
    267         /**
    268          * @defgroup drvusbhid USB HID driver
    269          * @ingroup usb
    270          * @brief USB driver for HID devices.
    271          */
    272 
    273         /**
    274          * @defgroup drvusbmouse USB mouse driver
    275          * @ingroup usb
    276          * @brief USB driver for mouse with boot protocol.
    277          */
    278 
    279         /**
    280          * @defgroup drvusbmast USB mass storage driver
    281          * @ingroup usb
    282          * @brief USB driver for mass storage devices (bulk-only protocol).
    283          * This driver is a only a stub and is currently used only for
    284          * testing that bulk transfers work.
    285          */
    286 
    287         /**
    288          * @defgroup drvusbuhci UHCI driver
    289          * @ingroup usb
    290          * @brief Drivers for USB UHCI host controller and root hub.
    291          */
    292 
    293                 /**
    294                  * @defgroup drvusbuhcirh UHCI root hub driver
    295                  * @ingroup drvusbuhci
    296                  * @brief Driver for UHCI complaint root hub.
    297                  */
    298 
    299                 /**
    300                  * @defgroup drvusbuhcihc UHCI host controller driver
    301                  * @ingroup drvusbuhci
    302                  * @brief Driver for UHCI complaint USB host controller.
    303                  */
    304 
    305         /**
    306          * @defgroup drvusbohci OHCI driver
    307          * @ingroup usb
    308          * @brief Driver for OHCI host controller.
    309          */
    310 
    311         /**
    312          * @defgroup drvusbehci EHCI driver
    313          * @ingroup usb
    314          * @brief Driver for EHCI host controller.
    315          */
    316 
    317         /**
    318          * @defgroup drvusbfallback USB fallback driver
    319          * @ingroup usb
    320          * @brief Fallback driver for any USB device.
    321          * @details
    322          * The purpose of this driver is to simplify querying of unknown
    323          * devices from within HelenOS (without a driver, no node at all
    324          * may appear under /dev/devices).
    325          */
    326 
    327 

  • uspace/drv/pciintel/pci.c

    rdf29f24 r5d1b3aa  
    5252#include <ipc/devman.h>
    5353#include <ipc/dev_iface.h>
    54 #include <ipc/irc.h>
    55 #include <ipc/ns.h>
    56 #include <ipc/services.h>
    57 #include <sysinfo.h>
    5854#include <ops/hw_res.h>
    5955#include <device/hw_res.h>
    6056#include <ddi.h>
    6157#include <libarch/ddi.h>
    62 #include <pci_dev_iface.h>
    6358
    6459#include "pci.h"
    … …  
    8984static bool pciintel_enable_interrupt(ddf_fun_t *fnode)
    9085{
    91         /* This is an old ugly way, copied from ne2000 driver */
    92         assert(fnode);
    93         pci_fun_t *dev_data = (pci_fun_t *) fnode->driver_data;
    94 
    95         sysarg_t apic;
    96         sysarg_t i8259;
    97 
    98         int irc_phone = ENOTSUP;
    99 
    100         if (((sysinfo_get_value("apic", &apic) == EOK) && (apic))
    101             || ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259))) {
    102                 irc_phone = service_connect_blocking(SERVICE_IRC, 0, 0);
    103         }
    104 
    105         if (irc_phone < 0) {
    106                 return false;
    107         }
    108 
    109         size_t i = 0;
    110         hw_resource_list_t *res = &dev_data->hw_resources;
    111         for (; i < res->count; i++) {
    112                 if (res->resources[i].type == INTERRUPT) {
    113                         const int irq = res->resources[i].res.interrupt.irq;
    114                         const int rc =
    115                             async_req_1_0(irc_phone, IRC_ENABLE_INTERRUPT, irq);
    116                         if (rc != EOK) {
    117                                 async_hangup(irc_phone);
    118                                 return false;
    119                         }
    120                 }
    121         }
    122 
    123         async_hangup(irc_phone);
    124         return true;
    125 }
    126 
    127 static int pci_config_space_write_32(
    128     ddf_fun_t *fun, uint32_t address, uint32_t data)
    129 {
    130         if (address > 252)
    131                 return EINVAL;
    132         pci_conf_write_32(PCI_FUN(fun), address, data);
    133         return EOK;
    134 }
    135 
    136 static int pci_config_space_write_16(
    137     ddf_fun_t *fun, uint32_t address, uint16_t data)
    138 {
    139         if (address > 254)
    140                 return EINVAL;
    141         pci_conf_write_16(PCI_FUN(fun), address, data);
    142         return EOK;
    143 }
    144 
    145 static int pci_config_space_write_8(
    146     ddf_fun_t *fun, uint32_t address, uint8_t data)
    147 {
    148         if (address > 255)
    149                 return EINVAL;
    150         pci_conf_write_8(PCI_FUN(fun), address, data);
    151         return EOK;
    152 }
    153 
    154 static int pci_config_space_read_32(
    155     ddf_fun_t *fun, uint32_t address, uint32_t *data)
    156 {
    157         if (address > 252)
    158                 return EINVAL;
    159         *data = pci_conf_read_32(PCI_FUN(fun), address);
    160         return EOK;
    161 }
    162 
    163 static int pci_config_space_read_16(
    164     ddf_fun_t *fun, uint32_t address, uint16_t *data)
    165 {
    166         if (address > 254)
    167                 return EINVAL;
    168         *data = pci_conf_read_16(PCI_FUN(fun), address);
    169         return EOK;
    170 }
    171 
    172 static int pci_config_space_read_8(
    173     ddf_fun_t *fun, uint32_t address, uint8_t *data)
    174 {
    175         if (address > 255)
    176                 return EINVAL;
    177         *data = pci_conf_read_8(PCI_FUN(fun), address);
    178         return EOK;
     86        /* TODO */
     87       
     88        return false;
    17989}
    18090
    … …  
    18494};
    18595
    186 static pci_dev_iface_t pci_dev_ops = {
    187         .config_space_read_8 = &pci_config_space_read_8,
    188         .config_space_read_16 = &pci_config_space_read_16,
    189         .config_space_read_32 = &pci_config_space_read_32,
    190         .config_space_write_8 = &pci_config_space_write_8,
    191         .config_space_write_16 = &pci_config_space_write_16,
    192         .config_space_write_32 = &pci_config_space_write_32
    193 };
    194 
    195 static ddf_dev_ops_t pci_fun_ops = {
    196         .interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops,
    197         .interfaces[PCI_DEV_IFACE] = &pci_dev_ops
    198 };
     96static ddf_dev_ops_t pci_fun_ops;
    19997
    20098static int pci_add_device(ddf_dev_t *);
    … …  
    390288        /* Get the value of the BAR. */
    391289        val = pci_conf_read_32(fun, addr);
    392 
    393 #define IO_MASK  (~0x3)
    394 #define MEM_MASK (~0xf)
    395290       
    396291        io = (bool) (val & 1);
    397292        if (io) {
    398293                addrw64 = false;
    399                 mask = IO_MASK;
    400294        } else {
    401                 mask = MEM_MASK;
    402295                switch ((val >> 1) & 3) {
    403296                case 0:
    … …  
    415308        /* Get the address mask. */
    416309        pci_conf_write_32(fun, addr, 0xffffffff);
    417         mask &= pci_conf_read_32(fun, addr);
     310        mask = pci_conf_read_32(fun, addr);
    418311       
    419312        /* Restore the original value. */
    … …  
    665558        ddf_log_init(NAME, LVL_ERROR);
    666559        pci_fun_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops;
    667         pci_fun_ops.interfaces[PCI_DEV_IFACE] = &pci_dev_ops;
    668560}
    669561
    … …  
    737629size_t pci_bar_mask_to_size(uint32_t mask)
    738630{
    739         size_t size = mask & ~(mask - 1);
    740         return size;
     631        return ((mask & 0xfffffff0) ^ 0xffffffff) + 1;
    741632}
    742633

  • uspace/drv/rootvirt/devices.def

    rdf29f24 r5d1b3aa  
    2626},
    2727#endif
    28 #ifdef CONFIG_RUN_VIRTUAL_USB_HC
    29 /* Virtual USB host controller. */
    30 {
    31         .name = "usbhc",
    32         .match_id = "usb&hc=vhc"
    33 },
    34 #endif

  • uspace/lib/c/Makefile

    rdf29f24 r5d1b3aa  
    7676        generic/str.c \
    7777        generic/str_error.c \
    78         generic/l18n/langs.c \
    7978        generic/fibril.c \
    8079        generic/fibril_synch.c \

  • uspace/lib/c/generic/adt/hash_table.c

    rdf29f24 r5d1b3aa  
    5454 *
    5555 */
    56 bool hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
     56int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
    5757    hash_table_operations_t *op)
    5858{

  • uspace/lib/c/generic/as.c

    rdf29f24 r5d1b3aa  
    3535#include <as.h>
    3636#include <libc.h>
    37 #include <errno.h>
    3837#include <unistd.h>
    3938#include <align.h>
    … …  
    115114}
    116115
    117 /** Find mapping to physical address.
    118  *
    119  * @param address Virtual address in question (virtual).
    120  * @param[out] frame Frame address (physical).
    121  * @return Error code.
    122  * @retval EOK No error, @p frame holds the translation.
    123  * @retval ENOENT Mapping not found.
    124  */
    125 int as_get_physical_mapping(void *address, uintptr_t *frame)
    126 {
    127         uintptr_t tmp_frame;
    128         uintptr_t virt = (uintptr_t) address;
    129        
    130         int rc = (int) __SYSCALL2(SYS_PAGE_FIND_MAPPING,
    131             (sysarg_t) virt, (sysarg_t) &tmp_frame);
    132         if (rc != EOK) {
    133                 return rc;
    134         }
    135        
    136         if (frame != NULL) {
    137                 *frame = tmp_frame;
    138         }
    139        
    140         return EOK;
    141 }
    142 
    143116/** @}
    144117 */

  • uspace/lib/c/generic/async.c

    rdf29f24 r5d1b3aa  
    15691569}
    15701570
    1571 /** Start IPC_M_DATA_READ using the async framework.
    1572  *
    1573  * @param phoneid Phone that will be used to contact the receiving side.
    1574  * @param dst Address of the beginning of the destination buffer.
    1575  * @param size Size of the destination buffer (in bytes).
    1576  * @param dataptr Storage of call data (arg 2 holds actual data size).
    1577  * @return Hash of the sent message or 0 on error.
    1578  */
    1579 aid_t async_data_read(int phoneid, void *dst, size_t size, ipc_call_t *dataptr)
    1580 {
    1581         return async_send_2(phoneid, IPC_M_DATA_READ, (sysarg_t) dst,
    1582             (sysarg_t) size, dataptr);
    1583 }
    1584 
    15851571/** Wrapper for IPC_M_DATA_READ calls using the async framework.
    15861572 *

  • uspace/lib/c/generic/devman.c

    rdf29f24 r5d1b3aa  
    374374}
    375375
    376 int devman_get_device_path(devman_handle_t handle, char *path, size_t path_size)
    377 {
    378         int phone = devman_get_phone(DEVMAN_CLIENT, 0);
    379 
    380         if (phone < 0)
    381                 return phone;
    382 
    383         async_serialize_start();
    384 
    385         ipc_call_t answer;
    386         aid_t req = async_send_1(phone, DEVMAN_DEVICE_GET_DEVICE_PATH,
    387             handle, &answer);
    388 
    389         ipc_call_t data_request_call;
    390         aid_t data_request = async_data_read(phone, path, path_size,
    391             &data_request_call);
    392         if (data_request == 0) {
    393                 async_wait_for(req, NULL);
    394                 async_serialize_end();
    395                 return ENOMEM;
    396         }
    397 
    398         sysarg_t data_request_rc;
    399         sysarg_t opening_request_rc;
    400         async_wait_for(data_request, &data_request_rc);
    401         async_wait_for(req, &opening_request_rc);
    402 
    403         async_serialize_end();
    404 
    405         if (data_request_rc != EOK) {
    406                 /* Prefer the return code of the opening request. */
    407                 if (opening_request_rc != EOK) {
    408                         return (int) opening_request_rc;
    409                 } else {
    410                         return (int) data_request_rc;
    411                 }
    412         }
    413         if (opening_request_rc != EOK) {
    414                 return (int) opening_request_rc;
    415         }
    416 
    417         /* To be on the safe-side. */
    418         path[path_size - 1] = 0;
    419 
    420         size_t transferred_size = IPC_GET_ARG2(data_request_call);
    421 
    422         if (transferred_size >= path_size) {
    423                 return ELIMIT;
    424         }
    425 
    426         /* Terminate the string (trailing 0 not send over IPC). */
    427         path[transferred_size] = 0;
    428 
    429         return EOK;
    430 }
    431 
    432376
    433377/** @}

  • uspace/lib/c/generic/malloc.c

    rdf29f24 r5d1b3aa  
    291291        size_t asize = ALIGN_UP(size, PAGE_SIZE);
    292292       
    293         astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE);
     293        astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ);
    294294        if (astart == (void *) -1)
    295295                return false;

  • uspace/lib/c/generic/str_error.c

    rdf29f24 r5d1b3aa  
    3333 */
    3434
    35 #include <errno.h>
    3635#include <str_error.h>
    3736#include <stdio.h>
    … …  
    6463static fibril_local char noerr[NOERR_LEN];
    6564
    66 const char *str_error(const int e)
     65const char *str_error(const int errno)
    6766{
    68         if ((e <= 0) && (e >= MIN_ERRNO))
    69                 return err_desc[-e];
     67        if ((errno <= 0) && (errno >= MIN_ERRNO))
     68                return err_desc[-errno];
    7069       
    71         /* Ad hoc descriptions of error codes interesting for USB. */
    72         switch (e) {
    73                 case EBADCHECKSUM:
    74                         return "Bad checksum";
    75                 case ESTALL:
    76                         return "Operation stalled";
    77                 case EAGAIN:
    78                         return "Resource temporarily unavailable";
    79                 case EEMPTY:
    80                         return "Resource is empty";
    81                 default:
    82                         break;
    83         }
    84 
    85         snprintf(noerr, NOERR_LEN, "Unkown error code %d", e);
     70        snprintf(noerr, NOERR_LEN, "Unkown error code %d", errno);
    8671        return noerr;
    8772}

  • uspace/lib/c/generic/time.c

    rdf29f24 r5d1b3aa  
    207207}
    208208
    209 void udelay(useconds_t time)
    210 {
    211         (void) __SYSCALL1(SYS_THREAD_UDELAY, (sysarg_t) time);
    212 }
    213 
    214 
    215209/** Wait unconditionally for specified number of seconds
    216210 *

  • uspace/lib/c/include/adt/hash_table.h

    rdf29f24 r5d1b3aa  
    3838#include <adt/list.h>
    3939#include <unistd.h>
    40 #include <bool.h>
    4140
    4241typedef unsigned long hash_count_t;
    … …  
    8483    list_get_instance((item), type, member)
    8584
    86 extern bool hash_table_create(hash_table_t *, hash_count_t, hash_count_t,
     85extern int hash_table_create(hash_table_t *, hash_count_t, hash_count_t,
    8786    hash_table_operations_t *);
    8887extern void hash_table_insert(hash_table_t *, unsigned long [], link_t *);

  • uspace/lib/c/include/as.h

    rdf29f24 r5d1b3aa  
    6060extern void *set_maxheapsize(size_t);
    6161extern void *as_get_mappable_page(size_t);
    62 extern int as_get_physical_mapping(void *, uintptr_t *);
    6362
    6463#endif

  • uspace/lib/c/include/async.h

    rdf29f24 r5d1b3aa  
    340340            (arg4), (answer))
    341341
    342 extern aid_t async_data_read(int, void *, size_t, ipc_call_t *);
    343342#define async_data_read_start(p, buf, len) \
    344343        async_data_read_start_generic((p), (buf), (len), IPC_XF_NONE)

  • uspace/lib/c/include/devman.h

    rdf29f24 r5d1b3aa  
    5555extern int devman_device_get_handle_by_class(const char *, const char *,
    5656    devman_handle_t *, unsigned int);
    57 extern int devman_get_device_path(devman_handle_t, char *, size_t);
    5857
    5958extern int devman_add_device_to_class(devman_handle_t, const char *);

  • uspace/lib/c/include/errno.h

    rdf29f24 r5d1b3aa  
    5656#define EMLINK        (-266)
    5757
    58 /** Bad checksum. */
    59 #define EBADCHECKSUM  (-300)
    60 
    61 /** USB: stalled operation. */
    62 #define ESTALL (-301)
    63 
    64 /** Empty resource (no data). */
    65 #define EEMPTY (-302)
    66 
    67 /** Negative acknowledgment. */
    68 #define ENAK (-303)
    69 
    7058/** An API function is called while another blocking function is in progress. */
    7159#define EINPROGRESS  (-10036)

  • uspace/lib/c/include/ipc/dev_iface.h

    rdf29f24 r5d1b3aa  
    3737        HW_RES_DEV_IFACE = 0,
    3838        CHAR_DEV_IFACE,
    39 
    40         /** Interface provided by any PCI device. */
    41         PCI_DEV_IFACE,
    42 
    43         /** Interface provided by any USB device. */
    44         USB_DEV_IFACE,
    45         /** Interface provided by USB host controller. */
    46         USBHC_DEV_IFACE,
    47         /** Interface provided by USB HID devices. */
    48         USBHID_DEV_IFACE,
    49 
    5039        DEV_IFACE_MAX
    5140} dev_inferface_idx_t;
    … …  
    5948        DEV_IFACE_ID(DEV_FIRST_CUSTOM_METHOD_IDX)
    6049
    61 /*
    62  * The first argument is actually method (as the "real" method is used
    63  * for indexing into interfaces.
    64  */
    65 
    66 #define DEV_IPC_GET_ARG1(call) IPC_GET_ARG2((call))
    67 #define DEV_IPC_GET_ARG2(call) IPC_GET_ARG3((call))
    68 #define DEV_IPC_GET_ARG3(call) IPC_GET_ARG4((call))
    69 #define DEV_IPC_GET_ARG4(call) IPC_GET_ARG5((call))
    70 
    7150
    7251#endif

  • uspace/lib/c/include/ipc/devman.h

    rdf29f24 r5d1b3aa  
    149149typedef enum {
    150150        DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD,
    151         DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
    152         DEVMAN_DEVICE_GET_DEVICE_PATH
     151        DEVMAN_DEVICE_GET_HANDLE_BY_CLASS
    153152} client_to_devman_t;
    154153

  • uspace/lib/c/include/ipc/kbd.h

    rdf29f24 r5d1b3aa  
    3939
    4040#include <ipc/common.h>
    41 #include <ipc/dev_iface.h>
    4241
    4342typedef enum {
    44         KBD_YIELD = DEV_FIRST_CUSTOM_METHOD,
     43        KBD_YIELD = IPC_FIRST_USER_METHOD,
    4544        KBD_RECLAIM
    4645} kbd_request_t;

  • uspace/lib/c/include/sys/time.h

    rdf29f24 r5d1b3aa  
    6262extern int gettimeofday(struct timeval *tv, struct timezone *tz);
    6363
    64 extern void udelay(useconds_t);
    65 
    6664#endif
    6765

  • uspace/lib/drv/Makefile

    rdf29f24 r5d1b3aa  
    2929
    3030USPACE_PREFIX = ../..
    31 EXTRA_CFLAGS = -Iinclude -I$(LIBUSB_PREFIX)/include
     31EXTRA_CFLAGS = -Iinclude
    3232LIBRARY = libdrv
    3333
    … …  
    3535        generic/driver.c \
    3636        generic/dev_iface.c \
    37         generic/remote_char_dev.c \
    3837        generic/log.c \
    3938        generic/remote_hw_res.c \
    40         generic/remote_usb.c \
    41         generic/remote_pci.c \
    42         generic/remote_usbhc.c \
    43         generic/remote_usbhid.c
     39        generic/remote_char_dev.c
    4440
    4541include $(USPACE_PREFIX)/Makefile.common

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

    rdf29f24 r5d1b3aa  
    4141#include "remote_hw_res.h"
    4242#include "remote_char_dev.h"
    43 #include "remote_usb.h"
    44 #include "remote_usbhc.h"
    45 #include "remote_usbhid.h"
    46 #include "remote_pci.h"
    47 
    48 #include <stdio.h>
    4943
    5044static iface_dipatch_table_t remote_ifaces = {
    5145        .ifaces = {
    5246                &remote_hw_res_iface,
    53                 &remote_char_dev_iface,
    54                 &remote_pci_iface,
    55                 &remote_usb_iface,
    56                 &remote_usbhc_iface,
    57                 &remote_usbhid_iface
     47                &remote_char_dev_iface
    5848        }
    5949};
    … …  
    6252{
    6353        assert(is_valid_iface_idx(idx));
    64        
    6554        return remote_ifaces.ifaces[idx];
    6655}

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

    rdf29f24 r5d1b3aa  
    405405                                /* The interface has not such method */
    406406                                printf("%s: driver_connection_gen error - "
    407                                     "invalid interface method "
    408                                     "(index %" PRIun ").\n",
    409                                     driver->name, iface_method_idx);
     407                                    "invalid interface method.", driver->name);
    410408                                async_answer_0(callid, ENOTSUP);
    411409                                break;

  • uspace/srv/devman/main.c

    rdf29f24 r5d1b3aa  
    515515}
    516516
    517 /** Find device path by its handle. */
    518 static void devman_get_device_path_by_handle(ipc_callid_t iid,
    519     ipc_call_t *icall)
    520 {
    521         devman_handle_t handle = IPC_GET_ARG1(*icall);
    522 
    523         fun_node_t *fun = find_fun_node(&device_tree, handle);
    524         if (fun == NULL) {
    525                 async_answer_0(iid, ENOMEM);
    526                 return;
    527         }
    528 
    529         ipc_callid_t data_callid;
    530         size_t data_len;
    531         if (!async_data_read_receive(&data_callid, &data_len)) {
    532                 async_answer_0(iid, EINVAL);
    533                 return;
    534         }
    535 
    536         void *buffer = malloc(data_len);
    537         if (buffer == NULL) {
    538                 async_answer_0(data_callid, ENOMEM);
    539                 async_answer_0(iid, ENOMEM);
    540                 return;
    541         }
    542 
    543         size_t sent_length = str_size(fun->pathname);
    544         if (sent_length > data_len) {
    545                 sent_length = data_len;
    546         }
    547 
    548         async_data_read_finalize(data_callid, fun->pathname, sent_length);
    549         async_answer_0(iid, EOK);
    550 
    551         free(buffer);
    552 }
    553 
    554517
    555518/** Function for handling connections from a client to the device manager. */
    … …  
    574537                        devman_function_get_handle_by_class(callid, &call);
    575538                        break;
    576                 case DEVMAN_DEVICE_GET_DEVICE_PATH:
    577                         devman_get_device_path_by_handle(callid, &call);
    578                         break;
    579539                default:
    580540                        async_answer_0(callid, ENOENT);
    … …  
    635595        if (driver == NULL) {
    636596                log_msg(LVL_ERROR, "IPC forwarding refused - " \
    637                     "the device %" PRIun "(%s) is not in usable state.",
    638                     handle, dev->pfun->pathname);
     597                    "the device %" PRIun " is not in usable state.", handle);
    639598                async_answer_0(iid, ENOENT);
    640599                return;

  • uspace/srv/fs/fat/fat_dentry.c

    rdf29f24 r5d1b3aa  
    4242static bool is_d_char(const char ch)
    4343{
    44         if (isalnum(ch) || ch == '_' || ch == '-')
     44        if (isalnum(ch) || ch == '_')
    4545                return true;
    4646        else

  • uspace/srv/hid/console/console.c

    rdf29f24 r5d1b3aa  
    4141#include <ipc/ns.h>
    4242#include <errno.h>
    43 #include <str_error.h>
    4443#include <ipc/console.h>
    4544#include <unistd.h>
    … …  
    5756#include <io/style.h>
    5857#include <io/screenbuffer.h>
    59 #include <inttypes.h>
    6058
    6159#include "console.h"
    … …  
    6664#define NAME       "console"
    6765#define NAMESPACE  "term"
    68 /** Interval for checking for new keyboard (1/4s). */
    69 #define HOTPLUG_WATCH_INTERVAL (1000 * 250)
    70 
    71 /* Kernel defines 32 but does not export it. */
    72 #define MAX_IPC_OUTGOING_PHONES 128
    73 /** To allow proper phone closing. */
    74 static ipc_callid_t driver_phones[MAX_IPC_OUTGOING_PHONES] = { 0 };
    7566
    7667/** Phone to the keyboard driver. */
    … …  
    9788} console_t;
    9889
    99 
    100 
    10190/** Array of data for virtual consoles */
    10291static console_t consoles[CONSOLE_COUNT];
    … …  
    328317static void change_console(console_t *cons)
    329318{
    330         if (cons == active_console) {
     319        if (cons == active_console)
    331320                return;
    332         }
    333321       
    334322        fb_pending_flush();
    … …  
    409397}
    410398
    411 static void close_driver_phone(ipc_callid_t hash)
    412 {
    413         int i;
    414         for (i = 0; i < MAX_IPC_OUTGOING_PHONES; i++) {
    415                 if (driver_phones[i] == hash) {
    416                         printf("Device %" PRIxn " gone.\n", hash);
    417                         driver_phones[i] = 0;
    418                         async_hangup(i);
    419                         return;
    420                 }
    421         }
    422 }
    423 
    424399/** Handler for keyboard */
    425400static void keyboard_events(ipc_callid_t iid, ipc_call_t *icall)
    … …  
    436411                case IPC_M_PHONE_HUNGUP:
    437412                        /* TODO: Handle hangup */
    438                         close_driver_phone(iid);
    439413                        return;
    440414                case KBD_EVENT:
    … …  
    480454                case IPC_M_PHONE_HUNGUP:
    481455                        /* TODO: Handle hangup */
    482                         close_driver_phone(iid);
    483456                        return;
    484457                case MEVENT_BUTTON:
    485458                        if (IPC_GET_ARG1(call) == 1) {
    486459                                int newcon = gcons_mouse_btn((bool) IPC_GET_ARG2(call));
    487                                 if (newcon != -1) {
     460                                if (newcon != -1)
    488461                                        change_console(&consoles[newcon]);
    489                                 }
    490462                        }
    491463                        retval = 0;
    … …  
    738710}
    739711
    740 static int async_connect_to_me_hack(int phone, sysarg_t arg1, sysarg_t arg2,
    741 sysarg_t arg3, async_client_conn_t client_receiver, ipc_callid_t *hash)
    742 {
    743         sysarg_t task_hash;
    744         sysarg_t phone_hash;
    745         int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3,
    746             NULL, NULL, NULL, &task_hash, &phone_hash);
    747         if (rc != EOK)
    748                 return rc;
    749 
    750         if (client_receiver != NULL)
    751                 async_new_connection(task_hash, phone_hash, phone_hash, NULL,
    752                     client_receiver);
    753 
    754         if (hash != NULL) {
    755                 *hash = phone_hash;
    756         }
    757 
    758         return EOK;
    759 }
    760 
    761 static int connect_keyboard_or_mouse(const char *devname,
    762     async_client_conn_t handler, const char *path)
    763 {
    764         int fd = open(path, O_RDONLY);
    765         if (fd < 0) {
    766                 return fd;
    767         }
    768        
    769         int phone = fd_phone(fd);
    770         close(fd);
    771         if (phone < 0) {
     712static bool console_init(char *input)
     713{
     714        /* Connect to input device */
     715        int input_fd = open(input, O_RDONLY);
     716        if (input_fd < 0) {
     717                printf(NAME ": Failed opening %s\n", input);
     718                return false;
     719        }
     720       
     721        kbd_phone = fd_phone(input_fd);
     722        if (kbd_phone < 0) {
    772723                printf(NAME ": Failed to connect to input device\n");
    773                 return phone;
    774         }
    775        
    776         ipc_callid_t hash;
    777         int rc = async_connect_to_me_hack(phone, SERVICE_CONSOLE, 0, phone,
    778             handler, &hash);
    779         if (rc != EOK) {
    780                 async_hangup(phone);
    781                 printf(NAME ": " \
    782                     "Failed to create callback from input device: %s.\n",
    783                     str_error(rc));
    784                 return rc;
    785         }
    786        
    787         driver_phones[phone] = hash;
    788 
    789         printf(NAME ": found %s \"%s\" (%" PRIxn ").\n", devname, path, hash);
    790 
    791         return phone;
    792 }
    793 
    794 static int connect_keyboard(const char *path)
    795 {
    796         return connect_keyboard_or_mouse("keyboard", keyboard_events, path);
    797 }
    798 
    799 static int connect_mouse(const char *path)
    800 {
    801         return connect_keyboard_or_mouse("mouse", mouse_events, path);
    802 }
    803 
    804 struct hid_class_info {
    805         char *classname;
    806         int (*connection_func)(const char *);
    807 };
    808 
    809 /** Periodically check for new keyboards in /dev/class/.
    810  *
    811  * @param arg Class name.
    812  * @return This function should never exit.
    813  */
    814 static int check_new_device_fibril(void *arg)
    815 {
    816         struct hid_class_info *dev_info = arg;
    817 
    818         size_t index = 1;
    819 
    820         while (true) {
    821                 async_usleep(HOTPLUG_WATCH_INTERVAL);
    822                 char *path;
    823                 int rc = asprintf(&path, "/dev/class/%s\\%zu",
    824                     dev_info->classname, index);
    825                 if (rc < 0) {
    826                         continue;
    827                 }
    828                 rc = 0;
    829                 rc = dev_info->connection_func(path);
    830                 if (rc > 0) {
    831                         /* We do not allow unplug. */
    832                         index++;
    833                 }
    834 
    835                 free(path);
    836         }
    837 
    838         return EOK;
    839 }
    840 
    841 
    842 /** Start a fibril monitoring hot-plugged keyboards.
    843  */
    844 static void check_new_devices_in_background(int (*connection_func)(const char *),
    845     const char *classname)
    846 {
    847         struct hid_class_info *dev_info = malloc(sizeof(struct hid_class_info));
    848         if (dev_info == NULL) {
    849                 printf(NAME ": " \
    850                     "out of memory, will not start hot-plug-watch fibril.\n");
    851                 return;
    852         }
    853         int rc;
    854 
    855         rc = asprintf(&dev_info->classname, "%s", classname);
    856         if (rc < 0) {
    857                 printf(NAME ": failed to format classname: %s.\n",
    858                     str_error(rc));
    859                 return;
    860         }
    861         dev_info->connection_func = connection_func;
    862 
    863         fid_t fid = fibril_create(check_new_device_fibril, (void *)dev_info);
    864         if (!fid) {
    865                 printf(NAME
    866                     ": failed to create hot-plug-watch fibril for %s.\n",
    867                     classname);
    868                 return;
    869         }
    870         fibril_add_ready(fid);
    871 }
    872 
    873 static bool console_init(char *input)
    874 {
    875         /* Connect to input device */
    876         kbd_phone = connect_keyboard(input);
    877         if (kbd_phone < 0) {
    878724                return false;
    879725        }
    880 
    881         mouse_phone = connect_mouse("/dev/hid_in/mouse");
     726       
     727        /* NB: The callback connection is slotted for removal */
     728        if (async_connect_to_me(kbd_phone, SERVICE_CONSOLE, 0, 0, keyboard_events)
     729            != 0) {
     730                printf(NAME ": Failed to create callback from input device\n");
     731                return false;
     732        }
     733       
     734        /* Connect to mouse device */
     735        mouse_phone = -1;
     736        int mouse_fd = open("/dev/hid_in/mouse", O_RDONLY);
     737       
     738        if (mouse_fd < 0) {
     739                printf(NAME ": Notice - failed opening %s\n", "/dev/hid_in/mouse");
     740                goto skip_mouse;
     741        }
     742       
     743        mouse_phone = fd_phone(mouse_fd);
    882744        if (mouse_phone < 0) {
    883                 printf(NAME ": Failed to connect to mouse device: %s.\n",
    884                     str_error(mouse_phone));
    885         }
     745                printf(NAME ": Failed to connect to mouse device\n");
     746                goto skip_mouse;
     747        }
     748       
     749        if (async_connect_to_me(mouse_phone, SERVICE_CONSOLE, 0, 0, mouse_events)
     750            != 0) {
     751                printf(NAME ": Failed to create callback from mouse device\n");
     752                mouse_phone = -1;
     753                goto skip_mouse;
     754        }
     755       
     756skip_mouse:
    886757       
    887758        /* Connect to framebuffer driver */
    … …  
    966837                printf(NAME ": Error registering kconsole notifications\n");
    967838       
    968         /* Start fibril for checking on hot-plugged keyboards. */
    969         check_new_devices_in_background(connect_keyboard, "keyboard");
    970         check_new_devices_in_background(connect_mouse, "mouse");
    971 
    972839        return true;
    973840}
    … …  
    989856        if (!console_init(argv[1]))
    990857                return -1;
    991 
     858       
    992859        printf(NAME ": Accepting connections\n");
    993860        async_manager();

  • uspace/srv/hw/irc/apic/apic.c

    rdf29f24 r5d1b3aa  
    8787                        async_answer_0(callid, EOK);
    8888                        break;
    89                 case IPC_M_PHONE_HUNGUP:
    90                         /* The other side has hung up. */
    91                         async_answer_0(callid, EOK);
    92                         return;
    9389                default:
    9490                        async_answer_0(callid, EINVAL);

  • uspace/srv/hw/irc/i8259/i8259.c

    rdf29f24 r5d1b3aa  
    121121                        async_answer_0(callid, EOK);
    122122                        break;
    123                 case IPC_M_PHONE_HUNGUP:
    124                         /* The other side has hung up. */
    125                         async_answer_0(callid, EOK);
    126                         return;
    127123                default:
    128124                        async_answer_0(callid, EINVAL);
Note: See TracChangeset for help on using the changeset viewer.