Changes in / [27bdfa5:917a8c8] in mainline


Ignore:
Files:
202 deleted
36 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    r27bdfa5 r917a8c8  
    550550
    551551% Launch (devman) test drivers
    552 ! [CONFIG_DEBUG=y] CONFIG_TEST_DRIVERS (n/y)
    553 
    554 % Start virtual USB host controller
    555 ! CONFIG_RUN_VIRTUAL_USB_HC (n/y)
    556 
    557 % Polling UHCI & OHCI (no interrupts)
    558 ! [PLATFORM=ia32|PLATFORM=amd64] CONFIG_USBHC_NO_INTERRUPTS (y/n)
    559 
    560 % Run devman in kconsole (not recommended)
    561 ! CONFIG_DEVMAN_EARLY_LAUNCH (n/y)
    562 
     552! [CONFIG_DEBUG=y] CONFIG_TEST_DRIVERS (y/n)
     553

  • Makefile

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

  • boot/Makefile.common

    r27bdfa5 r917a8c8  
    139139        $(USPACE_PATH)/app/ping/ping \
    140140        $(USPACE_PATH)/app/stats/stats \
     141        $(USPACE_PATH)/app/top/top \
    141142        $(USPACE_PATH)/app/sysinfo/sysinfo \
    142         $(USPACE_PATH)/app/tasks/tasks \
    143         $(USPACE_PATH)/app/top/top \
    144         $(USPACE_PATH)/app/usbinfo/usbinfo \
    145         $(USPACE_PATH)/app/virtusbkbd/vuk \
    146         $(USPACE_PATH)/app/virtusbhub/vuh \
    147143        $(USPACE_PATH)/app/websrv/websrv
    148144

  • boot/arch/amd64/Makefile.inc

    r27bdfa5 r917a8c8  
    4242        pciintel \
    4343        isa \
    44         ns8250 \
    45         ehci-hcd \
    46         ohci \
    47         uhci-hcd \
    48         uhci-rhd \
    49         usbflbk \
    50         usbhub \
    51         usbkbd \
    52         usbmid \
    53         usbmouse \
    54         vhc
     44        ns8250
    5545
    5646RD_DRV_CFG += \

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

    r27bdfa5 r917a8c8  
    3737
    3838#include <typedefs.h>
    39 #include <proc/task.h>
    4039#include <mm/as.h>
    4140#include <memstr.h>
    … …  
    6362extern uintptr_t hw_map(uintptr_t, size_t);
    6463
    65 extern sysarg_t sys_page_find_mapping(uintptr_t, uintptr_t *);
    66 
    6764#endif
    6865

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

    r27bdfa5 r917a8c8  
    6161        SYS_AS_GET_UNMAPPED_AREA,
    6262       
    63         SYS_PAGE_FIND_MAPPING,
    64        
    6563        SYS_IPC_CALL_SYNC_FAST,
    6664        SYS_IPC_CALL_SYNC_SLOW,

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

    r27bdfa5 r917a8c8  
    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
    6255#define KLOG_PAGES    4
    63 #endif
    64 
    6556#define KLOG_LENGTH   (KLOG_PAGES * PAGE_SIZE / sizeof(wchar_t))
    6657#define KLOG_LATENCY  8

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

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

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

    r27bdfa5 r917a8c8  
    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. */
    … …  
    177173}
    178174
    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  */
    185 sysarg_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 
    210175/** @}
    211176 */

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

    r27bdfa5 r917a8c8  
    4141#include <proc/program.h>
    4242#include <mm/as.h>
    43 #include <mm/page.h>
    4443#include <print.h>
    4544#include <arch.h>
    … …  
    146145        (syshandler_t) sys_as_get_unmapped_area,
    147146       
    148         /* Page mapping related syscalls. */
    149         (syshandler_t) sys_page_find_mapping,
    150        
    151147        /* IPC related syscalls. */
    152148        (syshandler_t) sys_ipc_call_sync_fast,

  • uspace/Makefile

    r27bdfa5 r917a8c8  
    5050        app/trace \
    5151        app/top \
    52         app/usbinfo \
    53         app/virtusbkbd \
    54         app/virtusbhub \
    5552        app/netecho \
    5653        app/nettest1 \
    … …  
    116113                drv/ns8250 \
    117114                srv/hw/irc/apic \
    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/usbhub \
    126                 drv/usbmid \
    127                 drv/usbmouse \
    128                 drv/vhc
     115                srv/hw/irc/i8259
    129116endif
    130117
    … …  
    136123                drv/ns8250 \
    137124                srv/hw/irc/apic \
    138                 srv/hw/irc/i8259 \
    139                 drv/ehci-hcd \
    140                 drv/ohci \
    141                 drv/uhci-hcd \
    142                 drv/uhci-rhd \
    143                 drv/usbflbk \
    144                 drv/usbkbd \
    145                 drv/usbhub \
    146                 drv/usbmid \
    147                 drv/usbmouse \
    148                 drv/vhc
     125                srv/hw/irc/i8259
    149126endif
    150127
    … …  
    172149        lib/packet \
    173150        lib/net
    174 
    175 ifeq ($(UARCH),amd64)
    176         LIBS += lib/usb
    177         LIBS += lib/usbvirt
    178 endif
    179 
    180 ifeq ($(UARCH),ia32)
    181         LIBS += lib/usb
    182         LIBS += lib/usbvirt
    183 endif
    184151
    185152LIBC_BUILD = $(addsuffix .build,$(LIBC))

  • uspace/Makefile.common

    r27bdfa5 r917a8c8  
    8686LIBCLUI_PREFIX = $(LIB_PREFIX)/clui
    8787
    88 
    89 LIBUSB_PREFIX = $(LIB_PREFIX)/usb
    90 LIBUSBVIRT_PREFIX = $(LIB_PREFIX)/usbvirt
    9188LIBDRV_PREFIX = $(LIB_PREFIX)/drv
    9289LIBPACKET_PREFIX = $(LIB_PREFIX)/packet

  • uspace/app/init/init.c

    r27bdfa5 r917a8c8  
    313313        getterm("term/vc5", "/app/bdsh", false);
    314314        getterm("term/vc6", "/app/klog", false);
    315 
    316 #ifdef CONFIG_DEVMAN_EARLY_LAUNCH
    317         spawn("/srv/devman");
    318 #else
    319         getterm("term/vc7", "/srv/devman", false);
    320 #endif
    321 
     315       
    322316        return 0;
    323317}

  • uspace/app/klog/klog.c

    r27bdfa5 r917a8c8  
    4444#include <io/klog.h>
    4545#include <sysinfo.h>
    46 #include <fibril_synch.h>
    4746
    4847#define NAME       "klog"
    … …  
    5554static FILE *log;
    5655
    57 /* Serialize the output a bit. This will not avoid messed-up log completely
    58    but chances for are pretty high (experimentally confirmed). */
    59 static FIBRIL_MUTEX_INITIALIZE(log_mutex);
    60 
    6156static void interrupt_received(ipc_callid_t callid, ipc_call_t *call)
    6257{
    63         fibril_mutex_lock(&log_mutex);
    64        
    6558        size_t klog_start = (size_t) IPC_GET_ARG1(*call);
    6659        size_t klog_len = (size_t) IPC_GET_ARG2(*call);
    … …  
    8174                fsync(fileno(log));
    8275        }
    83        
    84         fibril_mutex_unlock(&log_mutex);
    8576}
    8677

  • uspace/app/tester/Makefile

    r27bdfa5 r917a8c8  
    3131BINARY = tester
    3232
    33 LIBS += $(LIBUSB_PREFIX)/libusb.a
    34 EXTRA_CFLAGS += -I$(LIBUSB_PREFIX)/include
    35 
    3633SOURCES = \
    3734        tester.c \
    38         adt/usbaddrkeep.c \
    3935        thread/thread1.c \
    4036        print/print1.c \
    … …  
    5349        loop/loop1.c \
    5450        mm/malloc1.c \
    55         mm/mapping1.c \
    5651        hw/misc/virtchar1.c \
    5752        hw/serial/serial1.c

  • uspace/app/tester/tester.c

    r27bdfa5 r917a8c8  
    6262#include "loop/loop1.def"
    6363#include "mm/malloc1.def"
    64 #include "mm/mapping1.def"
    6564#include "hw/serial/serial1.def"
    66 #include "adt/usbaddrkeep.def"
    6765#include "hw/misc/virtchar1.def"
    6866        {NULL, NULL, NULL, false}

  • uspace/app/tester/tester.h

    r27bdfa5 r917a8c8  
    7878extern const char *test_loop1(void);
    7979extern const char *test_malloc1(void);
    80 extern const char *test_mapping1(void);
    8180extern const char *test_serial1(void);
    82 extern const char *test_usbaddrkeep(void);
    8381extern const char *test_virtchar1(void);
    8482

  • uspace/doc/doxygroups.h

    r27bdfa5 r917a8c8  
    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 drvusbehci EHCI driver
    272          * @ingroup usb
    273          * @brief Driver for EHCI host controller.
    274          */
    275 
    276         /**
    277          * @defgroup drvusbfallback USB fallback driver.
    278          * @ingroup usb
    279          * @brief Fallback driver for any USB device.
    280          * @details
    281          * The purpose of this driver is to simplify querying of unknown
    282          * devices from within HelenOS (without a driver, no node at all
    283          * may appear under /dev/devices).
    284          */
    285 
    286 

  • uspace/drv/pciintel/pci.c

    r27bdfa5 r917a8c8  
    5151#include <ipc/devman.h>
    5252#include <ipc/dev_iface.h>
    53 #include <ipc/irc.h>
    54 #include <ipc/ns.h>
    55 #include <ipc/services.h>
    56 #include <sysinfo.h>
    5753#include <ops/hw_res.h>
    5854#include <device/hw_res.h>
    5955#include <ddi.h>
    6056#include <libarch/ddi.h>
    61 #include <pci_dev_iface.h>
    6257
    6358#include "pci.h"
    … …  
    8883static bool pciintel_enable_interrupt(ddf_fun_t *fnode)
    8984{
    90         /* This is an old ugly way, copied from ne2000 driver */
    91         assert(fnode);
    92         pci_fun_t *dev_data = (pci_fun_t *) fnode->driver_data;
    93 
    94         sysarg_t apic;
    95         sysarg_t i8259;
    96 
    97         int irc_phone = ENOTSUP;
    98 
    99         if (((sysinfo_get_value("apic", &apic) == EOK) && (apic))
    100             || ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259))) {
    101                 irc_phone = service_connect_blocking(SERVICE_IRC, 0, 0);
    102         }
    103 
    104         if (irc_phone < 0) {
    105                 return false;
    106         }
    107 
    108         size_t i;
    109         for (i = 0; i < dev_data->hw_resources.count; i++) {
    110                 if (dev_data->hw_resources.resources[i].type == INTERRUPT) {
    111                         int irq = dev_data->hw_resources.resources[i].res.interrupt.irq;
    112                         int rc = async_req_1_0(irc_phone, IRC_ENABLE_INTERRUPT, irq);
    113                         if (rc != EOK) {
    114                                 async_hangup(irc_phone);
    115                                 return false;
    116                         }
    117                 }
    118         }
    119 
    120         async_hangup(irc_phone);
    121         return true;
    122 }
    123 
    124 static int pci_config_space_write_32(
    125     ddf_fun_t *fun, uint32_t address, uint32_t data)
    126 {
    127         if (address > 252)
    128                 return EINVAL;
    129         pci_conf_write_32(PCI_FUN(fun), address, data);
    130         return EOK;
    131 }
    132 
    133 static int pci_config_space_write_16(
    134     ddf_fun_t *fun, uint32_t address, uint16_t data)
    135 {
    136         if (address > 254)
    137                 return EINVAL;
    138         pci_conf_write_16(PCI_FUN(fun), address, data);
    139         return EOK;
    140 }
    141 
    142 static int pci_config_space_write_8(
    143     ddf_fun_t *fun, uint32_t address, uint8_t data)
    144 {
    145         if (address > 255)
    146                 return EINVAL;
    147         pci_conf_write_8(PCI_FUN(fun), address, data);
    148         return EOK;
    149 }
    150 
    151 static int pci_config_space_read_32(
    152     ddf_fun_t *fun, uint32_t address, uint32_t *data)
    153 {
    154         if (address > 252)
    155                 return EINVAL;
    156         *data = pci_conf_read_32(PCI_FUN(fun), address);
    157         return EOK;
    158 }
    159 
    160 static int pci_config_space_read_16(
    161     ddf_fun_t *fun, uint32_t address, uint16_t *data)
    162 {
    163         if (address > 254)
    164                 return EINVAL;
    165         *data = pci_conf_read_16(PCI_FUN(fun), address);
    166         return EOK;
    167 }
    168 
    169 static int pci_config_space_read_8(
    170     ddf_fun_t *fun, uint32_t address, uint8_t *data)
    171 {
    172         if (address > 255)
    173                 return EINVAL;
    174         *data = pci_conf_read_8(PCI_FUN(fun), address);
    175         return EOK;
     85        /* TODO */
     86       
     87        return false;
    17688}
    17789
    … …  
    18193};
    18294
    183 static pci_dev_iface_t pci_dev_ops = {
    184         .config_space_read_8 = &pci_config_space_read_8,
    185         .config_space_read_16 = &pci_config_space_read_16,
    186         .config_space_read_32 = &pci_config_space_read_32,
    187         .config_space_write_8 = &pci_config_space_write_8,
    188         .config_space_write_16 = &pci_config_space_write_16,
    189         .config_space_write_32 = &pci_config_space_write_32
    190 };
    191 
    192 static ddf_dev_ops_t pci_fun_ops = {
    193         .interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops,
    194         .interfaces[PCI_DEV_IFACE] = &pci_dev_ops
    195 };
     95static ddf_dev_ops_t pci_fun_ops;
    19696
    19797static int pci_add_device(ddf_dev_t *);
    … …  
    387287        /* Get the value of the BAR. */
    388288        val = pci_conf_read_32(fun, addr);
    389 
    390 #define IO_MASK  (~0x3)
    391 #define MEM_MASK (~0xf)
    392289       
    393290        io = (bool) (val & 1);
    394291        if (io) {
    395292                addrw64 = false;
    396                 mask = IO_MASK;
    397293        } else {
    398                 mask = MEM_MASK;
    399294                switch ((val >> 1) & 3) {
    400295                case 0:
    … …  
    412307        /* Get the address mask. */
    413308        pci_conf_write_32(fun, addr, 0xffffffff);
    414         mask &= pci_conf_read_32(fun, addr);
     309        mask = pci_conf_read_32(fun, addr);
    415310       
    416311        /* Restore the original value. */
    … …  
    660555{
    661556        pci_fun_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops;
    662         pci_fun_ops.interfaces[PCI_DEV_IFACE] = &pci_dev_ops;
    663557}
    664558
    … …  
    732626size_t pci_bar_mask_to_size(uint32_t mask)
    733627{
    734         size_t size = mask & ~(mask - 1);
    735         return size;
     628        return ((mask & 0xfffffff0) ^ 0xffffffff) + 1;
    736629}
    737630

  • uspace/drv/rootvirt/devices.def

    r27bdfa5 r917a8c8  
    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

    r27bdfa5 r917a8c8  
    6565        generic/str.c \
    6666        generic/str_error.c \
    67         generic/l18n/langs.c \
    6867        generic/fibril.c \
    6968        generic/fibril_synch.c \

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

    r27bdfa5 r917a8c8  
    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

    r27bdfa5 r917a8c8  
    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  */
    1577 aid_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 
    15831569/** Wrapper for IPC_M_DATA_READ calls using the async framework.
    15841570 *

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

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

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

    r27bdfa5 r917a8c8  
    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/include/as.h

    r27bdfa5 r917a8c8  
    6060extern void *set_maxheapsize(size_t mhs);
    6161extern void * as_get_mappable_page(size_t sz);
    62 extern int as_get_physical_mapping(void *address, uintptr_t *frame);
    6362
    6463#endif

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

    r27bdfa5 r917a8c8  
    340340            (arg4), (answer))
    341341
    342 extern aid_t async_data_read(int, void *, size_t, ipc_call_t *);
    343342extern int async_data_read_start(int, void *, size_t);
    344343extern bool async_data_read_receive(ipc_callid_t *, size_t *);

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

    r27bdfa5 r917a8c8  
    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 
    6758/** An API function is called while another blocking function is in progress. */
    6859#define EINPROGRESS  (-10036)

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

    r27bdfa5 r917a8c8  
    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 
    4839        DEV_IFACE_MAX
    4940} dev_inferface_idx_t;
    … …  
    5748        DEV_IFACE_ID(DEV_FIRST_CUSTOM_METHOD_IDX)
    5849
    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 
    6950
    7051#endif

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

    r27bdfa5 r917a8c8  
    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/drv/Makefile

    r27bdfa5 r917a8c8  
    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/remote_hw_res.c \
    39         generic/remote_usb.c \
    40         generic/remote_pci.c \
    41         generic/remote_usbhc.c
     38        generic/remote_char_dev.c
    4239
    4340include $(USPACE_PREFIX)/Makefile.common

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

    r27bdfa5 r917a8c8  
    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"
    4643
    4744static iface_dipatch_table_t remote_ifaces = {
    4845        .ifaces = {
    4946                &remote_hw_res_iface,
    50                 &remote_char_dev_iface,
    51                 &remote_pci_iface,
    52                 &remote_usb_iface,
    53                 &remote_usbhc_iface
     47                &remote_char_dev_iface
    5448        }
    5549};

  • uspace/srv/devman/devman.c

    r27bdfa5 r917a8c8  
    148148        printf(NAME": the '%s' driver was added to the list of available "
    149149            "drivers.\n", drv->name);
    150 
    151         printf(NAME ": match ids:");
    152         link_t *cur;
    153         for (cur = drv->match_ids.ids.next; cur != &drv->match_ids.ids; cur = cur->next) {
    154                 match_id_t *match_id = list_get_instance(cur, match_id_t, link);
    155                 printf(" %d:%s", match_id->score, match_id->id);
    156         }
    157         printf("\n");
    158150}
    159151

  • uspace/srv/devman/main.c

    r27bdfa5 r917a8c8  
    513513       
    514514        if (driver == NULL) {
    515                 printf(NAME ": devman_forward error - the device %" PRIun \
    516                     " (%s) is not in usable state.\n",
    517                     handle, dev->pfun->pathname);
     515                printf(NAME ": devman_forward error - the device is not in %" PRIun
     516                    " usable state.\n", handle);
    518517                async_answer_0(iid, ENOENT);
    519518                return;

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

    r27bdfa5 r917a8c8  
    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

    r27bdfa5 r917a8c8  
    4141#include <ipc/ns.h>
    4242#include <errno.h>
    43 #include <str_error.h>
    4443#include <ipc/console.h>
    4544#include <unistd.h>
    … …  
    6564#define NAME       "console"
    6665#define NAMESPACE  "term"
    67 /** Interval for checking for new keyboard (1/4s). */
    68 #define HOTPLUG_WATCH_INTERVAL (1000 * 250)
    6966
    7067/** Phone to the keyboard driver. */
    … …  
    320317static void change_console(console_t *cons)
    321318{
    322         if (cons == active_console) {
     319        if (cons == active_console)
    323320                return;
    324         }
    325321       
    326322        fb_pending_flush();
    … …  
    462458                        if (IPC_GET_ARG1(call) == 1) {
    463459                                int newcon = gcons_mouse_btn((bool) IPC_GET_ARG2(call));
    464                                 if (newcon != -1) {
     460                                if (newcon != -1)
    465461                                        change_console(&consoles[newcon]);
    466                                 }
    467462                        }
    468463                        retval = 0;
    … …  
    715710}
    716711
    717 static 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) {
     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) {
    727723                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 
    744 static int connect_keyboard(const char *path)
    745 {
    746         return connect_keyboard_or_mouse("keyboard", keyboard_events, path);
    747 }
    748 
    749 static int connect_mouse(const char *path)
    750 {
    751         return connect_keyboard_or_mouse("mouse", mouse_events, path);
    752 }
    753 
    754 struct 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  */
    764 static 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  */
    794 static 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 
    823 static bool console_init(char *input)
    824 {
    825         /* Connect to input device */
    826         kbd_phone = connect_keyboard(input);
    827         if (kbd_phone < 0) {
    828724                return false;
    829725        }
    830 
    831         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);
    832744        if (mouse_phone < 0) {
    833                 printf(NAME ": Failed to connect to mouse device: %s.\n",
    834                     str_error(mouse_phone));
    835         }
     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:
    836757       
    837758        /* Connect to framebuffer driver */
    … …  
    916837                printf(NAME ": Error registering kconsole notifications\n");
    917838       
    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 
    922839        return true;
    923840}
    … …  
    939856        if (!console_init(argv[1]))
    940857                return -1;
    941 
     858       
    942859        printf(NAME ": Accepting connections\n");
    943860        async_manager();
Note: See TracChangeset for help on using the changeset viewer.