Changes in / [17279ead:b77ce84] in mainline


Ignore:
Files:
242 added
39 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    r17279ead rb77ce84  
    529529
    530530% Run devman on startup
    531 ! CONFIG_START_DEVMAN (y/n)
     531! CONFIG_START_DEVMAN (y)
    532532
    533533% Launch (devman) test drivers
    … …  
    554554% Line debugging information
    555555! [CONFIG_STRIP_BINARIES!=y] CONFIG_LINE_DEBUG (n/y)
     556
     557% Start virtual USB host controller
     558! CONFIG_RUN_VIRTUAL_USB_HC (n/y)
     559
     560% Polling UHCI & OHCI (no interrupts)
     561! [PLATFORM=ia32|PLATFORM=amd64] CONFIG_USBHC_NO_INTERRUPTS (y/n)
     562
     563% Run devman in kconsole (not recommended)
     564! CONFIG_DEVMAN_EARLY_LAUNCH (n/y)

  • Makefile

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

  • boot/Makefile.common

    r17279ead rb77ce84  
    139139        $(USPACE_PATH)/app/ping/ping \
    140140        $(USPACE_PATH)/app/stats/stats \
     141        $(USPACE_PATH)/app/sysinfo/sysinfo \
     142        $(USPACE_PATH)/app/tasks/tasks \
    141143        $(USPACE_PATH)/app/top/top \
    142         $(USPACE_PATH)/app/sysinfo/sysinfo \
     144        $(USPACE_PATH)/app/usbinfo/usbinfo \
     145        $(USPACE_PATH)/app/virtusbkbd/vuk \
     146        $(USPACE_PATH)/app/virtusbhub/vuh \
    143147        $(USPACE_PATH)/app/websrv/websrv
    144148

  • boot/arch/amd64/Makefile.inc

    r17279ead rb77ce84  
    4242        pciintel \
    4343        isa \
    44         ns8250
     44        ns8250 \
     45        ehci-hcd \
     46        ohci \
     47        uhci-hcd \
     48        uhci-rhd \
     49        usbflbk \
     50        usbhub \
     51        usbkbd \
     52        usbhid \
     53        usbmid \
     54        usbmouse \
     55        vhc
    4556
    4657RD_DRV_CFG += \

  • kernel/generic/include/mm/page.h

    r17279ead rb77ce84  
    3737
    3838#include <typedefs.h>
     39#include <proc/task.h>
    3940#include <mm/as.h>
    4041#include <memstr.h>
    … …  
    6263extern uintptr_t hw_map(uintptr_t, size_t);
    6364
     65extern sysarg_t sys_page_find_mapping(uintptr_t, uintptr_t *);
     66
    6467#endif
    6568

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

    r17279ead rb77ce84  
    6161        SYS_AS_GET_UNMAPPED_AREA,
    6262       
     63        SYS_PAGE_FIND_MAPPING,
     64       
    6365        SYS_IPC_CALL_SYNC_FAST,
    6466        SYS_IPC_CALL_SYNC_SLOW,

  • kernel/generic/src/console/console.c

    r17279ead rb77ce84  
    5353#include <str.h>
    5454
     55/*
     56 * devman produces a lot of output and by giving so many pages
     57 * we to allow /app/klog to catch-up.
     58 */
     59#ifdef CONFIG_DEVMAN_EARLY_LAUNCH
     60#define KLOG_PAGES    64
     61#else
    5562#define KLOG_PAGES    4
     63#endif
     64
    5665#define KLOG_LENGTH   (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t))
    5766#define KLOG_LATENCY  8

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

    r17279ead rb77ce84  
    19491949sysarg_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags)
    19501950{
    1951         if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address,
     1951        if (as_area_create(AS, flags, size, address,
    19521952            AS_AREA_ATTR_NONE, &anon_backend, NULL))
    19531953                return (sysarg_t) address;

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

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

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

    r17279ead rb77ce84  
    4141#include <proc/program.h>
    4242#include <mm/as.h>
     43#include <mm/page.h>
    4344#include <print.h>
    4445#include <arch.h>
    … …  
    145146        (syshandler_t) sys_as_get_unmapped_area,
    146147       
     148        /* Page mapping related syscalls. */
     149        (syshandler_t) sys_page_find_mapping,
     150       
    147151        /* IPC related syscalls. */
    148152        (syshandler_t) sys_ipc_call_sync_fast,

  • uspace/Makefile

    r17279ead rb77ce84  
    5050        app/trace \
    5151        app/top \
     52        app/usbinfo \
     53        app/virtusbkbd \
     54        app/virtusbhub \
    5255        app/netecho \
    5356        app/nettest1 \
    … …  
    113116                drv/ns8250 \
    114117                srv/hw/irc/apic \
    115                 srv/hw/irc/i8259
     118                srv/hw/irc/i8259 \
     119                drv/ehci-hcd \
     120                drv/ohci \
     121                drv/uhci-hcd \
     122                drv/uhci-rhd \
     123                drv/usbflbk \
     124                drv/usbkbd \
     125                drv/usbhid \
     126                drv/usbhub \
     127                drv/usbmid \
     128                drv/usbmouse \
     129                drv/vhc
    116130endif
    117131
    … …  
    123137                drv/ns8250 \
    124138                srv/hw/irc/apic \
    125                 srv/hw/irc/i8259
     139                srv/hw/irc/i8259 \
     140                drv/ehci-hcd \
     141                drv/ohci \
     142                drv/uhci-hcd \
     143                drv/uhci-rhd \
     144                drv/usbflbk \
     145                drv/usbkbd \
     146                drv/usbhid \
     147                drv/usbhub \
     148                drv/usbmid \
     149                drv/usbmouse \
     150                drv/vhc
    126151endif
    127152
    … …  
    150175        lib/net
    151176
     177ifeq ($(UARCH),amd64)
     178        LIBS += lib/usb
     179        LIBS += lib/usbvirt
     180endif
     181
     182ifeq ($(UARCH),ia32)
     183        LIBS += lib/usb
     184        LIBS += lib/usbvirt
     185endif
     186
    152187LIBC_BUILD = $(addsuffix .build,$(LIBC))
    153188LIBS_BUILD = $(addsuffix .build,$(LIBS))

  • uspace/Makefile.common

    r17279ead rb77ce84  
    8686LIBCLUI_PREFIX = $(LIB_PREFIX)/clui
    8787
     88
     89LIBUSB_PREFIX = $(LIB_PREFIX)/usb
     90LIBUSBVIRT_PREFIX = $(LIB_PREFIX)/usbvirt
    8891LIBDRV_PREFIX = $(LIB_PREFIX)/drv
    8992LIBPACKET_PREFIX = $(LIB_PREFIX)/packet

  • uspace/app/init/init.c

    r17279ead rb77ce84  
    272272        mount_tmpfs();
    273273       
    274 #ifdef CONFIG_START_DEVMAN
    275         spawn("/srv/devman");
    276 #endif
    277274        spawn("/srv/apic");
    278275        spawn("/srv/i8259");
    … …  
    316313        getterm("term/vc5", "/app/bdsh", false);
    317314        getterm("term/vc6", "/app/klog", false);
    318        
     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
    319326        return 0;
    320327}

  • uspace/app/klog/klog.c

    r17279ead rb77ce84  
    4444#include <io/klog.h>
    4545#include <sysinfo.h>
     46#include <fibril_synch.h>
    4647
    4748#define NAME       "klog"
    … …  
    5455static FILE *log;
    5556
     57/* Serialize the output a bit. This will not avoid messed-up log completely
     58   but chances for are pretty high (experimentally confirmed). */
     59static FIBRIL_MUTEX_INITIALIZE(log_mutex);
     60
    5661static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
    5762{
     63        fibril_mutex_lock(&log_mutex);
     64       
    5865        size_t klog_start = (size_t) IPC_GET_ARG1(*call);
    5966        size_t klog_len = (size_t) IPC_GET_ARG2(*call);
    … …  
    7481                fsync(fileno(log));
    7582        }
     83       
     84        fibril_mutex_unlock(&log_mutex);
    7685}
    7786

  • uspace/app/tester/Makefile

    r17279ead rb77ce84  
    3131BINARY = tester
    3232
     33LIBS += $(LIBUSB_PREFIX)/libusb.a
     34EXTRA_CFLAGS += -I$(LIBUSB_PREFIX)/include
     35
    3336SOURCES = \
    3437        tester.c \
     38        adt/usbaddrkeep.c \
    3539        thread/thread1.c \
    3640        print/print1.c \
    … …  
    4953        loop/loop1.c \
    5054        mm/malloc1.c \
     55        mm/mapping1.c \
    5156        devs/devman1.c \
    5257        hw/misc/virtchar1.c \

  • uspace/app/tester/tester.c

    r17279ead rb77ce84  
    6262#include "loop/loop1.def"
    6363#include "mm/malloc1.def"
     64#include "mm/mapping1.def"
    6465#include "hw/serial/serial1.def"
     66#include "adt/usbaddrkeep.def"
    6567#include "hw/misc/virtchar1.def"
    6668#include "devs/devman1.def"

  • uspace/app/tester/tester.h

    r17279ead rb77ce84  
    7878extern const char *test_loop1(void);
    7979extern const char *test_malloc1(void);
     80extern const char *test_mapping1(void);
    8081extern const char *test_serial1(void);
     82extern const char *test_usbaddrkeep(void);
    8183extern const char *test_virtchar1(void);
    8284extern const char *test_devman1(void);

  • uspace/doc/doxygroups.h

    r17279ead rb77ce84  
    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 USB library
     175         * @ingroup usb
     176         * @brief Library for creating USB devices drivers.
     177         */
     178
     179        /**
     180         * @defgroup usbvirt USB virtualization
     181         * @ingroup usb
     182         * @brief Support for virtual USB devices.
     183         */
     184
     185                /**
     186                 * @defgroup libusbvirt USB virtualization library
     187                 * @ingroup usbvirt
     188                 * @brief Library for creating virtual USB devices.
     189                 */
     190
     191                /**
     192                 * @defgroup drvusbvhc Virtual USB host controller
     193                 * @ingroup usbvirt
     194                 * @brief Driver simulating work of USB host controller.
     195                 */
     196
     197                /**
     198                 * @defgroup usbvirthub Virtual USB hub
     199                 * @ingroup usbvirt
     200                 * @brief Extra virtual USB hub for virtual host controller.
     201                 * @details
     202                 * Some of the sources are shared with virtual host controller,
     203                 * see @ref drvusbvhc for the rest of the files.
     204                 */
     205
     206                /**
     207                 * @defgroup usbvirtkbd Virtual USB keybaord
     208                 * @ingroup usbvirt
     209                 * @brief Virtual USB keyboard for virtual host controller.
     210                 */
     211
     212        /**
     213         * @defgroup usbinfo USB info application
     214         * @ingroup usb
     215         * @brief Application for querying USB devices.
     216         * @details
     217         * The intended usage of this application is to query new USB devices
     218         * for their descriptors etc. to simplify driver writing.
     219         */
     220
     221        /**
     222         * @defgroup drvusbmid USB multi interface device driver
     223         * @ingroup usb
     224         * @brief USB multi interface device driver
     225         * @details
     226         * This driver serves as a mini hub (or bus) driver for devices
     227         * that have the class defined at interface level (those devices
     228         * usually have several interfaces).
     229         *
     230         * The term multi interface device driver (MID) was borrowed
     231         * Solaris operating system.
     232         */
     233
     234        /**
     235         * @defgroup drvusbhub USB hub driver
     236         * @ingroup usb
     237         * @brief USB hub driver.
     238         */
     239
     240        /**
     241         * @defgroup drvusbhid USB HID driver
     242         * @ingroup usb
     243         * @brief USB driver for HID devices.
     244         */
     245
     246        /**
     247         * @defgroup drvusbmouse USB mouse driver
     248         * @ingroup usb
     249         * @brief USB driver for mouse with boot protocol.
     250         */
     251
     252        /**
     253         * @defgroup drvusbuhci UHCI driver
     254         * @ingroup usb
     255         * @brief Drivers for USB UHCI host controller and root hub.
     256         */
     257
     258                /**
     259                 * @defgroup drvusbuhcirh UHCI root hub driver
     260                 * @ingroup drvusbuhci
     261                 * @brief Driver for UHCI complaint root hub.
     262                 */
     263
     264                /**
     265                 * @defgroup drvusbuhcihc UHCI host controller driver
     266                 * @ingroup drvusbuhci
     267                 * @brief Driver for UHCI complaint USB host controller.
     268                 */
     269
     270        /**
     271         * @defgroup drvusbohci OHCI driver
     272         * @ingroup usb
     273         * @brief Driver for OHCI host controller.
     274         */
     275
     276        /**
     277         * @defgroup drvusbehci EHCI driver
     278         * @ingroup usb
     279         * @brief Driver for EHCI host controller.
     280         */
     281
     282        /**
     283         * @defgroup drvusbfallback USB fallback driver
     284         * @ingroup usb
     285         * @brief Fallback driver for any USB device.
     286         * @details
     287         * The purpose of this driver is to simplify querying of unknown
     288         * devices from within HelenOS (without a driver, no node at all
     289         * may appear under /dev/devices).
     290         */
     291
     292

  • uspace/drv/pciintel/pci.c

    r17279ead rb77ce84  
    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>
    5458#include <ops/hw_res.h>
    5559#include <device/hw_res.h>
    5660#include <ddi.h>
    5761#include <libarch/ddi.h>
     62#include <pci_dev_iface.h>
    5863
    5964#include "pci.h"
    … …  
    8489static bool pciintel_enable_interrupt(ddf_fun_t *fnode)
    8590{
    86         /* TODO */
    87        
    88         return false;
     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
     127static 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
     136static 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
     145static 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
     154static 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
     163static 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
     172static 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;
    89179}
    90180
    … …  
    94184};
    95185
    96 static ddf_dev_ops_t pci_fun_ops;
     186static 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
     195static 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};
    97199
    98200static int pci_add_device(ddf_dev_t *);
    … …  
    288390        /* Get the value of the BAR. */
    289391        val = pci_conf_read_32(fun, addr);
     392
     393#define IO_MASK  (~0x3)
     394#define MEM_MASK (~0xf)
    290395       
    291396        io = (bool) (val & 1);
    292397        if (io) {
    293398                addrw64 = false;
     399                mask = IO_MASK;
    294400        } else {
     401                mask = MEM_MASK;
    295402                switch ((val >> 1) & 3) {
    296403                case 0:
    … …  
    308415        /* Get the address mask. */
    309416        pci_conf_write_32(fun, addr, 0xffffffff);
    310         mask = pci_conf_read_32(fun, addr);
     417        mask &= pci_conf_read_32(fun, addr);
    311418       
    312419        /* Restore the original value. */
    … …  
    558665        ddf_log_init(NAME, LVL_ERROR);
    559666        pci_fun_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops;
     667        pci_fun_ops.interfaces[PCI_DEV_IFACE] = &pci_dev_ops;
    560668}
    561669
    … …  
    629737size_t pci_bar_mask_to_size(uint32_t mask)
    630738{
    631         return ((mask & 0xfffffff0) ^ 0xffffffff) + 1;
     739        size_t size = mask & ~(mask - 1);
     740        return size;
    632741}
    633742

  • uspace/drv/rootvirt/devices.def

    r17279ead rb77ce84  
    2222},
    2323#endif
     24#ifdef CONFIG_RUN_VIRTUAL_USB_HC
     25/* Virtual USB host controller. */
     26{
     27        .name = "usbhc",
     28        .match_id = "usb&hc=vhc"
     29},
     30#endif

  • uspace/lib/c/Makefile

    r17279ead rb77ce84  
    6565        generic/str.c \
    6666        generic/str_error.c \
     67        generic/l18n/langs.c \
    6768        generic/fibril.c \
    6869        generic/fibril_synch.c \

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

    r17279ead rb77ce84  
    5454 *
    5555 */
    56 int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
     56bool 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

    r17279ead rb77ce84  
    3535#include <as.h>
    3636#include <libc.h>
     37#include <errno.h>
    3738#include <unistd.h>
    3839#include <align.h>
    … …  
    114115}
    115116
     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 */
     125int 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
    116143/** @}
    117144 */

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

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

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

    r17279ead rb77ce84  
    240240        size_t asize = ALIGN_UP(size, PAGE_SIZE);
    241241       
    242         astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ);
     242        astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE);
    243243        if (astart == (void *) -1)
    244244                return false;

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

    r17279ead rb77ce84  
    3333 */
    3434
     35#include <errno.h>
    3536#include <str_error.h>
    3637#include <stdio.h>
    … …  
    6364static fibril_local char noerr[NOERR_LEN];
    6465
    65 const char *str_error(const int errno)
     66const char *str_error(const int e)
    6667{
    67         if ((errno <= 0) && (errno >= MIN_ERRNO))
    68                 return err_desc[-errno];
     68        if ((e <= 0) && (e >= MIN_ERRNO))
     69                return err_desc[-e];
    6970       
    70         snprintf(noerr, NOERR_LEN, "Unkown error code %d", errno);
     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);
    7186        return noerr;
    7287}

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

    r17279ead rb77ce84  
    3838#include <adt/list.h>
    3939#include <unistd.h>
     40#include <bool.h>
    4041
    4142typedef unsigned long hash_count_t;
    … …  
    8384    list_get_instance((item), type, member)
    8485
    85 extern int hash_table_create(hash_table_t *, hash_count_t, hash_count_t,
     86extern bool hash_table_create(hash_table_t *, hash_count_t, hash_count_t,
    8687    hash_table_operations_t *);
    8788extern void hash_table_insert(hash_table_t *, unsigned long [], link_t *);

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

    r17279ead rb77ce84  
    6060extern void *set_maxheapsize(size_t mhs);
    6161extern void * as_get_mappable_page(size_t sz);
     62extern int as_get_physical_mapping(void *address, uintptr_t *frame);
    6263
    6364#endif

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

    r17279ead rb77ce84  
    340340            (arg4), (answer))
    341341
     342extern aid_t async_data_read(int, void *, size_t, ipc_call_t *);
    342343#define async_data_read_start(p, buf, len) \
    343344        async_data_read_start_generic((p), (buf), (len), IPC_XF_NONE)

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

    r17279ead rb77ce84  
    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
    5867/** An API function is called while another blocking function is in progress. */
    5968#define EINPROGRESS  (-10036)

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

    r17279ead rb77ce84  
    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
    3948        DEV_IFACE_MAX
    4049} dev_inferface_idx_t;
    … …  
    4857        DEV_IFACE_ID(DEV_FIRST_CUSTOM_METHOD_IDX)
    4958
     59/*
     60 * The first argument is actually method (as the "real" method is used
     61 * for indexing into interfaces.
     62 */
     63
     64#define DEV_IPC_GET_ARG1(call) IPC_GET_ARG2((call))
     65#define DEV_IPC_GET_ARG2(call) IPC_GET_ARG3((call))
     66#define DEV_IPC_GET_ARG3(call) IPC_GET_ARG4((call))
     67#define DEV_IPC_GET_ARG4(call) IPC_GET_ARG5((call))
     68
    5069
    5170#endif

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

    r17279ead rb77ce84  
    3939
    4040#include <ipc/common.h>
     41#include <ipc/dev_iface.h>
    4142
    4243typedef enum {
    43         KBD_YIELD = IPC_FIRST_USER_METHOD,
     44        KBD_YIELD = DEV_FIRST_CUSTOM_METHOD,
    4445        KBD_RECLAIM
    4546} kbd_request_t;

  • uspace/lib/drv/Makefile

    r17279ead rb77ce84  
    2929
    3030USPACE_PREFIX = ../..
    31 EXTRA_CFLAGS = -Iinclude
     31EXTRA_CFLAGS = -Iinclude -I$(LIBUSB_PREFIX)/include
    3232LIBRARY = libdrv
    3333
    … …  
    3535        generic/driver.c \
    3636        generic/dev_iface.c \
     37        generic/remote_char_dev.c \
    3738        generic/log.c \
    3839        generic/remote_hw_res.c \
    39         generic/remote_char_dev.c
     40        generic/remote_usb.c \
     41        generic/remote_pci.c \
     42        generic/remote_usbhc.c
    4043
    4144include $(USPACE_PREFIX)/Makefile.common

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

    r17279ead rb77ce84  
    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_pci.h"
    4346
    4447static iface_dipatch_table_t remote_ifaces = {
    4548        .ifaces = {
    4649                &remote_hw_res_iface,
    47                 &remote_char_dev_iface
     50                &remote_char_dev_iface,
     51                &remote_pci_iface,
     52                &remote_usb_iface,
     53                &remote_usbhc_iface
    4854        }
    4955};

  • uspace/srv/devman/main.c

    r17279ead rb77ce84  
    595595        if (driver == NULL) {
    596596                log_msg(LVL_ERROR, "IPC forwarding refused - " \
    597                     "the device %" PRIun " is not in usable state.", handle);
     597                    "the device %" PRIun "(%s) is not in usable state.",
     598                    handle, dev->pfun->pathname);
    598599                async_answer_0(iid, ENOENT);
    599600                return;

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

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

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

    r17279ead rb77ce84  
    4141#include <ipc/ns.h>
    4242#include <errno.h>
     43#include <str_error.h>
    4344#include <ipc/console.h>
    4445#include <unistd.h>
    … …  
    6465#define NAME       "console"
    6566#define NAMESPACE  "term"
     67/** Interval for checking for new keyboard (1/4s). */
     68#define HOTPLUG_WATCH_INTERVAL (1000 * 250)
    6669
    6770/** Phone to the keyboard driver. */
    … …  
    317320static void change_console(console_t *cons)
    318321{
    319         if (cons == active_console)
     322        if (cons == active_console) {
    320323                return;
     324        }
    321325       
    322326        fb_pending_flush();
    … …  
    458462                        if (IPC_GET_ARG1(call) == 1) {
    459463                                int newcon = gcons_mouse_btn((bool) IPC_GET_ARG2(call));
    460                                 if (newcon != -1)
     464                                if (newcon != -1) {
    461465                                        change_console(&consoles[newcon]);
     466                                }
    462467                        }
    463468                        retval = 0;
    … …  
    710715}
    711716
     717static int connect_keyboard_or_mouse(const char *devname,
     718    async_client_conn_t handler, const char *path)
     719{
     720        int fd = open(path, O_RDONLY);
     721        if (fd < 0) {
     722                return fd;
     723        }
     724       
     725        int phone = fd_phone(fd);
     726        if (phone < 0) {
     727                printf(NAME ": Failed to connect to input device\n");
     728                return phone;
     729        }
     730       
     731        int rc = async_connect_to_me(phone, SERVICE_CONSOLE, 0, 0, handler);
     732        if (rc != EOK) {
     733                printf(NAME ": " \
     734                    "Failed to create callback from input device: %s.\n",
     735                    str_error(rc));
     736                return rc;
     737        }
     738       
     739        printf(NAME ": found %s \"%s\".\n", devname, path);
     740
     741        return phone;
     742}
     743
     744static int connect_keyboard(const char *path)
     745{
     746        return connect_keyboard_or_mouse("keyboard", keyboard_events, path);
     747}
     748
     749static int connect_mouse(const char *path)
     750{
     751        return connect_keyboard_or_mouse("mouse", mouse_events, path);
     752}
     753
     754struct hid_class_info {
     755        char *classname;
     756        int (*connection_func)(const char *);
     757};
     758
     759/** Periodically check for new keyboards in /dev/class/.
     760 *
     761 * @param arg Class name.
     762 * @return This function should never exit.
     763 */
     764static int check_new_device_fibril(void *arg)
     765{
     766        struct hid_class_info *dev_info = arg;
     767
     768        size_t index = 1;
     769
     770        while (true) {
     771                async_usleep(HOTPLUG_WATCH_INTERVAL);
     772                char *path;
     773                int rc = asprintf(&path, "/dev/class/%s\\%zu",
     774                    dev_info->classname, index);
     775                if (rc < 0) {
     776                        continue;
     777                }
     778                rc = 0;
     779                rc = dev_info->connection_func(path);
     780                if (rc > 0) {
     781                        /* We do not allow unplug. */
     782                        index++;
     783                }
     784
     785                free(path);
     786        }
     787
     788        return EOK;
     789}
     790
     791
     792/** Start a fibril monitoring hot-plugged keyboards.
     793 */
     794static void check_new_devices_in_background(int (*connection_func)(const char *),
     795    const char *classname)
     796{
     797        struct hid_class_info *dev_info = malloc(sizeof(struct hid_class_info));
     798        if (dev_info == NULL) {
     799                printf(NAME ": " \
     800                    "out of memory, will not start hot-plug-watch fibril.\n");
     801                return;
     802        }
     803        int rc;
     804
     805        rc = asprintf(&dev_info->classname, "%s", classname);
     806        if (rc < 0) {
     807                printf(NAME ": failed to format classname: %s.\n",
     808                    str_error(rc));
     809                return;
     810        }
     811        dev_info->connection_func = connection_func;
     812
     813        fid_t fid = fibril_create(check_new_device_fibril, (void *)dev_info);
     814        if (!fid) {
     815                printf(NAME
     816                    ": failed to create hot-plug-watch fibril for %s.\n",
     817                    classname);
     818                return;
     819        }
     820        fibril_add_ready(fid);
     821}
     822
    712823static bool console_init(char *input)
    713824{
    714825        /* 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);
     826        kbd_phone = connect_keyboard(input);
     827        if (kbd_phone < 0) {
    718828                return false;
    719829        }
    720        
    721         kbd_phone = fd_phone(input_fd);
    722         if (kbd_phone < 0) {
    723                 printf(NAME ": Failed to connect to input device\n");
    724                 return false;
    725         }
    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);
     830
     831        mouse_phone = connect_mouse("/dev/hid_in/mouse");
    744832        if (mouse_phone < 0) {
    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        
    756 skip_mouse:
     833                printf(NAME ": Failed to connect to mouse device: %s.\n",
     834                    str_error(mouse_phone));
     835        }
    757836       
    758837        /* Connect to framebuffer driver */
    … …  
    837916                printf(NAME ": Error registering kconsole notifications\n");
    838917       
     918        /* Start fibril for checking on hot-plugged keyboards. */
     919        check_new_devices_in_background(connect_keyboard, "keyboard");
     920        check_new_devices_in_background(connect_mouse, "mouse");
     921
    839922        return true;
    840923}
    … …  
    856939        if (!console_init(argv[1]))
    857940                return -1;
    858        
     941
    859942        printf(NAME ": Accepting connections\n");
    860943        async_manager();

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

    r17279ead rb77ce84  
    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;
    8993                default:
    9094                        async_answer_0(callid, EINVAL);

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

    r17279ead rb77ce84  
    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;
    123127                default:
    124128                        async_answer_0(callid, EINVAL);
Note: See TracChangeset for help on using the changeset viewer.