Changes in / [b8b1e631:07fd4cd1] in mainline


Ignore:
Files:
198 added
566 deleted
55 edited

Legend:

Unmodified
Added
Removed

  • HelenOS.config

    rb8b1e631 r07fd4cd1  
    520520@ "1920x1080"
    521521@ "1920x1200"
    522 ! [(PLATFORM=ia32|PLATFORM=amd64)&CONFIG_HID_OUT!=none&CONFIG_FB=y] CONFIG_BFB_MODE (choice)
     522! [(PLATFORM=ia32|PLATFORM=amd64)&CONFIG_HID_OUT!=none&CONFIG_FB=y] CONFIG_VESA_MODE (choice)
    523523
    524524% Default framebuffer depth
    … …  
    526526@ "16"
    527527@ "24"
    528 ! [(PLATFORM=ia32|PLATFORM=amd64)&CONFIG_HID_OUT!=none&CONFIG_FB=y] CONFIG_BFB_BPP (choice)
     528! [(PLATFORM=ia32|PLATFORM=amd64)&CONFIG_HID_OUT!=none&CONFIG_FB=y] CONFIG_VESA_BPP (choice)
    529529
    530530% Start AP processors by the loader
    … …  
    570570! CONFIG_PCC (n/y)
    571571
    572 % Build binutils binaries
     572% Build binutils binaries 
    573573! CONFIG_BINUTILS (n/y)
    574574
    … …  
    576576! [CONFIG_STRIP_BINARIES!=y] CONFIG_LINE_DEBUG (n/y)
    577577
    578 # USB settings
     578# USB settings 
    579579
    580580% USB release build (less logging)
    … …  
    588588@ "ganged" Root hub ports are all powered or all off.
    589589@ "per_port" Powered status of every root hub port is independent.
    590 ! [PLATFORM=ia32|PLATFORM=amd64] OHCI_POWER_SWITCH (choice)
    591 
    592 % GRUB boot loader architecture
    593 @ "pc" GRUB for PC
    594 @ "efi" GRUB for UEFI
    595 ! [PLATFORM=ia32|PLATFORM=amd64] GRUB_ARCH (choice)
     590![PLATFORM=ia32|PLATFORM=amd64] OHCI_POWER_SWITCH (choice)

  • boot/Makefile

    rb8b1e631 r07fd4cd1  
    4040        $(PACK) $(OBJCOPY) $(BFD_NAME) $(BFD_ARCH) arch/$(KARCH) $(COMPONENTS)
    4141
    42 $(INITRD).img: build_dist
     42$(INITRD).img: $(INITRD).fs
     43        $(MKHORD) $(PAGE_SIZE) $< $@
     44
     45$(INITRD).fs: build_dist
    4346ifeq ($(RDFMT),tmpfs)
    4447        $(MKTMPFS) $(DIST_PATH) $@
    … …  
    9295
    9396clean_dist:
    94         rm -f $(INITRD).img $(COMPS_H) $(COMPS_C) $(LINK) $(LINK).comp *.co
     97        rm -f $(INITRD).fs $(INITRD).img $(COMPS_H) $(COMPS_C) $(LINK) $(LINK).comp *.co
    9598        rm -f $(USPACE_PATH)/dist/srv/*
    9699        rm -rf $(USPACE_PATH)/dist/drv/*

  • boot/Makefile.common

    rb8b1e631 r07fd4cd1  
    5353SANDBOX = pack
    5454PACK = $(TOOLS_PATH)/pack.py
     55MKHORD = $(TOOLS_PATH)/mkhord.py
    5556MKTMPFS = $(TOOLS_PATH)/mktmpfs.py
    5657MKFAT = $(TOOLS_PATH)/mkfat.py

  • boot/Makefile.grub

    rb8b1e631 r07fd4cd1  
    3131include Makefile.common
    3232
    33 GRUB = grub.$(GRUB_ARCH)
    34 BOOT = $(DISTROOT)/boot
    35 
    36 ELTORITO = boot/grub/$(GRUB_ARCH).img
    37 IMAGE = $(DISTROOT)/$(ELTORITO)
    38 
    39 ifeq ($(GRUB_ARCH),pc)
    40         BOOT_CONFIG = $(BOOT)/grub/i386-pc/grub.cfg
    41         MULTIBOOT_CMD = multiboot
    42         MODULE_CMD = module
    43 endif
    44 ifeq ($(GRUB_ARCH),efi)
    45         BOOT_CONFIG = $(BOOT)/grub/grub.cfg
    46         MULTIBOOT_CMD = multiboot2
    47         MODULE_CMD = module2
    48 endif
     33GRUB2 = grub
     34STAGE2 = $(GRUB2)/i386-pc/eltorito.img
     35STAGE2_IN = boot/$(STAGE2)
    4936
    5037all: $(BOOT_OUTPUT)
    5138
    5239$(BOOT_OUTPUT): build_dist
    53 ifeq ($(GRUB_ARCH),pc)
    54         mkisofs -J -r -input-charset utf-8 -V "HelenOS boot ISO" -eltorito-boot $(ELTORITO) -no-emul-boot -boot-load-size 64 -boot-info-table -o $@ $(DISTROOT)/
    55 endif
    56 ifeq ($(GRUB_ARCH),efi)
    57         mkisofs -J -r -input-charset utf-8 -V "HelenOS boot ISO" -efi-boot $(ELTORITO) -o $@ $(DISTROOT)/
    58 endif
     40        mkisofs -J -r -input-charset utf-8 -b $(STAGE2_IN) -no-emul-boot -boot-load-size 64 -boot-info-table -o $@ $(DISTROOT)/
    5941
    6042build_dist: clean
    61         mkdir -p $(BOOT)
    62         cp -r $(GRUB) $(BOOT)/grub
    63 ifeq ($(GRUB_ARCH),efi)
    64         gunzip $(IMAGE)
    65 endif
    66        
     43        mkdir -p $(DISTROOT)/boot
     44        cp -r $(GRUB2) $(DISTROOT)/boot
    6745        for module in $(COMPONENTS) ; do \
    68                 cp "$$module" $(BOOT)/ ; \
     46                cp "$$module" $(DISTROOT)/boot/ ; \
    6947        done
    7048       
    71         echo "set default=0" > $(BOOT_CONFIG)
    72         echo "set timeout=10" >> $(BOOT_CONFIG)
    73         echo "" >> $(BOOT_CONFIG)
     49        echo "set default=0" > $(DISTROOT)/boot/grub/i386-pc/grub.cfg
     50        echo "set timeout=10" >> $(DISTROOT)/boot/grub/i386-pc/grub.cfg
     51        echo "" >> $(DISTROOT)/boot/grub/i386-pc/grub.cfg
    7452       
    75 ifeq ($(GRUB_ARCH),pc)
    76         echo "insmod vbe" >> $(BOOT_CONFIG)
    77         echo "insmod vga" >> $(BOOT_CONFIG)
    78 endif
    79 ifeq ($(GRUB_ARCH),efi)
    80         echo "insmod efi_gop" >> $(BOOT_CONFIG)
    81         echo "insmod efi_uga" >> $(BOOT_CONFIG)
    82 endif
    83         echo "" >> $(BOOT_CONFIG)
     53        echo "menuentry 'HelenOS $(RELEASE)' --class helenos --class os {" >> $(DISTROOT)/boot/grub/i386-pc/grub.cfg
     54        echo "  set root='(cd)'" >> $(DISTROOT)/boot/grub/i386-pc/grub.cfg
    8455       
    85         echo "menuentry 'HelenOS $(RELEASE)' --class helenos --class os {" >> $(BOOT_CONFIG)
    8656        for module in $(MODULES) ; do \
    87                 echo "  echo 'Loading $$module'" >> $(BOOT_CONFIG) ; \
     57                echo "" >> $(DISTROOT)/boot/grub/i386-pc/grub.cfg ; \
     58                echo "  echo 'Loading $$module'" >> $(DISTROOT)/boot/grub/i386-pc/grub.cfg ; \
    8859                if [ "$$module" = "kernel.bin" ] ; then \
    89                         echo "  $(MULTIBOOT_CMD) /boot/$$module" >> $(BOOT_CONFIG) ; \
     60                        echo "  multiboot /boot/$$module" >> $(DISTROOT)/boot/grub/i386-pc/grub.cfg ; \
    9061                else \
    91                         echo "  $(MODULE_CMD) /boot/$$module" >> $(BOOT_CONFIG) ; \
     62                        echo "  module /boot/$$module" >> $(DISTROOT)/boot/grub/i386-pc/grub.cfg ; \
    9263                fi \
    9364        done
    94         echo "}" >> $(BOOT_CONFIG)
     65       
     66        echo "}" >> $(DISTROOT)/boot/grub/i386-pc/grub.cfg
    9567
    9668clean:

  • boot/arch/amd64/Makefile.inc

    rb8b1e631 r07fd4cd1  
    2626# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727#
     28
     29PAGE_SIZE = 4096
    2830
    2931RD_SRVS_ESSENTIAL += \

  • boot/arch/arm32/Makefile.inc

    rb8b1e631 r07fd4cd1  
    3939BITS = 32
    4040ENDIANESS = LE
     41PAGE_SIZE = 4096
    4142
    4243RD_SRVS_ESSENTIAL += \

  • boot/arch/ia64/Makefile.inc

    rb8b1e631 r07fd4cd1  
    3333BITS = 64
    3434ENDIANESS = LE
     35PAGE_SIZE = 16384
    3536EXTRA_CFLAGS = -fno-unwind-tables -mfixed-range=f32-f127 -mno-pic -mno-sdata
    3637

  • boot/arch/mips32/Makefile.inc

    rb8b1e631 r07fd4cd1  
    2929BFD_ARCH = mips
    3030BITS = 32
     31PAGE_SIZE = 16384
    3132EXTRA_CFLAGS = -mno-abicalls -G 0 -fno-zero-initialized-in-bss -mips3 -mabi=32
    3233

  • boot/arch/mips64/Makefile.inc

    rb8b1e631 r07fd4cd1  
    2929BFD_ARCH = mips:4000
    3030BITS = 64
     31PAGE_SIZE = 16384
    3132EXTRA_CFLAGS = -mno-abicalls -G 0 -fno-zero-initialized-in-bss -mips3 -mabi=64
    3233

  • boot/arch/ppc32/Makefile.inc

    rb8b1e631 r07fd4cd1  
    3737BITS = 32
    3838ENDIANESS = BE
     39PAGE_SIZE = 4096
    3940EXTRA_CFLAGS = -mcpu=powerpc -msoft-float -m32
    4041

  • boot/arch/sparc64/Makefile.inc

    rb8b1e631 r07fd4cd1  
    3737BITS = 64
    3838ENDIANESS = BE
     39PAGE_SIZE = 16384
    3940EXTRA_CFLAGS = -mcpu=ultrasparc -m64 -mno-fpu -mcmodel=medlow
    4041

  • defaults/amd64/Makefile.config

    rb8b1e631 r07fd4cd1  
    5454
    5555# Default framebuffer mode
    56 CONFIG_BFB_MODE = 800x600
     56CONFIG_VESA_MODE = 800x600
    5757
    5858# Default framebuffer depth
    59 CONFIG_BFB_BPP = 16
     59CONFIG_VESA_BPP = 16
    6060
    6161# Load disk drivers on startup
    … …  
    6767# OHCI root hub power switch, ganged is enough
    6868OHCI_POWER_SWITCH = ganged
    69 
    70 # GRUB boot loader architecture
    71 GRUB_ARCH = pc

  • defaults/ia32/Makefile.config

    rb8b1e631 r07fd4cd1  
    6060
    6161# Default framebuffer mode
    62 CONFIG_BFB_MODE = 800x600
     62CONFIG_VESA_MODE = 800x600
    6363
    6464# Default framebuffer depth
    65 CONFIG_BFB_BPP = 16
     65CONFIG_VESA_BPP = 16
    6666
    6767# Load disk drivers on startup
    … …  
    7373# OHCI root hub power switch, ganged is enough
    7474OHCI_POWER_SWITCH = ganged
    75 
    76 # GRUB boot loader architecture
    77 GRUB_ARCH = pc

  • kernel/arch/amd64/Makefile.inc

    rb8b1e631 r07fd4cd1  
    7272ARCH_SOURCES = \
    7373        arch/$(KARCH)/src/fpu_context.c \
    74         arch/$(KARCH)/src/boot/multiboot.S \
    75         arch/$(KARCH)/src/boot/multiboot2.S \
     74        arch/$(KARCH)/src/boot/boot.S \
    7675        arch/$(KARCH)/src/boot/memmap.c \
    7776        arch/$(KARCH)/src/debug/stacktrace.c \
    … …  
    8079        arch/$(KARCH)/src/context.S \
    8180        arch/$(KARCH)/src/ddi/ddi.c \
     81        arch/$(KARCH)/src/drivers/vesa.c \
    8282        arch/$(KARCH)/src/drivers/i8254.c \
    8383        arch/$(KARCH)/src/drivers/i8259.c \

  • kernel/arch/amd64/include/arch.h

    rb8b1e631 r07fd4cd1  
    3838#include <genarch/multiboot/multiboot.h>
    3939
    40 extern void arch_pre_main(uint32_t, void *);
     40extern void arch_pre_main(uint32_t, const multiboot_info_t *);
    4141
    4242#endif

  • kernel/arch/amd64/include/boot/boot.h

    rb8b1e631 r07fd4cd1  
    4040#define BOOT_STACK_SIZE  0x000400
    4141
     42#define MULTIBOOT_HEADER_MAGIC  0x1BADB002
     43#define MULTIBOOT_HEADER_FLAGS  0x00010003
     44
    4245#ifndef __ASM__
    4346

  • kernel/arch/amd64/src/amd64.c

    rb8b1e631 r07fd4cd1  
    4141#include <proc/thread.h>
    4242#include <genarch/multiboot/multiboot.h>
    43 #include <genarch/multiboot/multiboot2.h>
    4443#include <genarch/drivers/legacy/ia32/io.h>
    4544#include <genarch/drivers/ega/ega.h>
    46 #include <genarch/fb/bfb.h>
     45#include <arch/drivers/vesa.h>
    4746#include <genarch/drivers/i8042/i8042.h>
    4847#include <genarch/kbrd/kbrd.h>
    … …  
    102101/** Perform amd64-specific initialization before main_bsp() is called.
    103102 *
    104  * @param signature Multiboot signature.
    105  * @param info      Multiboot information structure.
    106  *
    107  */
    108 void arch_pre_main(uint32_t signature, void *info)
     103 * @param signature Should contain the multiboot signature.
     104 * @param mi        Pointer to the multiboot information structure.
     105 */
     106void arch_pre_main(uint32_t signature, const multiboot_info_t *mi)
    109107{
    110108        /* Parse multiboot information obtained from the bootloader. */
    111         multiboot_info_parse(signature, (multiboot_info_t *) info);
    112         multiboot2_info_parse(signature, (multiboot2_info_t *) info);
     109        multiboot_info_parse(signature, mi);
    113110       
    114111#ifdef CONFIG_SMP
    … …  
    156153               
    157154#if (defined(CONFIG_FB) || defined(CONFIG_EGA))
    158                 bool bfb = false;
     155                bool vesa = false;
    159156#endif
    160157               
    161158#ifdef CONFIG_FB
    162                 bfb = bfb_init();
     159                vesa = vesa_init();
    163160#endif
    164161               
    165162#ifdef CONFIG_EGA
    166                 if (!bfb) {
     163                if (!vesa) {
    167164                        outdev_t *egadev = ega_init(EGA_BASE, EGA_VIDEORAM);
    168165                        if (egadev)

  • kernel/arch/amd64/src/boot/memmap.c

    rb8b1e631 r07fd4cd1  
    3535#include <arch/boot/memmap.h>
    3636
    37 uint8_t e820counter = 0;
     37uint8_t e820counter = 0xffU;
    3838e820memmap_t e820table[MEMMAP_E820_MAX_RECORDS];
    3939

  • kernel/arch/ia32/Makefile.inc

    rb8b1e631 r07fd4cd1  
    106106        arch/$(KARCH)/src/drivers/i8254.c \
    107107        arch/$(KARCH)/src/drivers/i8259.c \
    108         arch/$(KARCH)/src/boot/multiboot.S \
    109         arch/$(KARCH)/src/boot/multiboot2.S \
     108        arch/$(KARCH)/src/drivers/vesa.c \
     109        arch/$(KARCH)/src/boot/boot.S \
    110110        arch/$(KARCH)/src/boot/memmap.c \
    111111        arch/$(KARCH)/src/fpu_context.c \

  • kernel/arch/ia32/include/arch.h

    rb8b1e631 r07fd4cd1  
    3636#define KERN_ia32_ARCH_H_
    3737
    38 #include <typedefs.h>
     38#include <genarch/multiboot/multiboot.h>
    3939
    40 extern void arch_pre_main(uint32_t, void *);
     40extern void arch_pre_main(uint32_t, const multiboot_info_t *);
    4141
    4242#endif

  • kernel/arch/ia32/include/boot/boot.h

    rb8b1e631 r07fd4cd1  
    4040#define BOOT_STACK_SIZE  0x0400
    4141
     42#define MULTIBOOT_HEADER_MAGIC  0x1BADB002
     43#define MULTIBOOT_HEADER_FLAGS  0x00010003
     44
     45#define MULTIBOOT_LOADER_MAGIC  0x2BADB002
     46
    4247#ifndef __ASM__
    4348

  • kernel/arch/ia32/src/boot/memmap.c

    rb8b1e631 r07fd4cd1  
    3535#include <arch/boot/memmap.h>
    3636
    37 uint8_t e820counter = 0;
     37uint8_t e820counter = 0xffU;
    3838e820memmap_t e820table[MEMMAP_E820_MAX_RECORDS];
    3939

  • kernel/arch/ia32/src/boot/vesa_prot.inc

    rb8b1e631 r07fd4cd1  
    11#ifdef CONFIG_FB
    22
     3#define MULTIBOOT_LOADER_MAGIC  0x2BADB002
    34#define MBINFO_BIT_CMDLINE      2
    45#define MBINFO_OFFSET_CMDLINE   16
    … …  
    1314        rep movsb
    1415       
    15         /* Check for multiboot command line */
     16        /* Check for GRUB command line */
    1617       
    17         pm_status $status_multiboot_cmdline
     18        pm_status $status_grub_cmdline
    1819       
    19         mov multiboot_eax, %eax
     20        mov grub_eax, %eax
    2021        cmp $MULTIBOOT_LOADER_MAGIC, %eax
    2122        jne no_cmdline
    2223       
    23         mov multiboot_ebx, %ebx
     24        mov grub_ebx, %ebx
    2425        mov (%ebx), %eax
    2526        bt $MBINFO_BIT_CMDLINE, %eax
    … …  
    8889                /* Returned back to protected mode */
    8990               
    90                 movzx %ax, %ecx
    91                 mov %ecx, KA2PA(bfb_scanline)
     91                mov %ax, KA2PA(vesa_scanline)
     92                shr $16, %eax
     93                mov %ax, KA2PA(vesa_bpp)
    9294               
    93                 shr $16, %eax
    94                 mov %ax, KA2PA(bfb_bpp)
     95                mov %bx, KA2PA(vesa_height)
     96                shr $16, %ebx
     97                mov %bx, KA2PA(vesa_width)
    9598               
    96                 movzx %bx, %ecx
    97                 mov %ecx, KA2PA(bfb_height)
    98                
    99                 shr $16, %ebx
    100                 mov %ebx, KA2PA(bfb_width)
    101                
    102                 mov %dl, KA2PA(bfb_green_pos)
    103                
     99                mov %dl, KA2PA(vesa_green_pos)
    104100                shr $8, %edx
    105                 mov %dl, KA2PA(bfb_green_size)
    106                
     101                mov %dl, KA2PA(vesa_green_mask)
    107102                shr $8, %edx
    108                 mov %dl, KA2PA(bfb_red_pos)
    109                
     103                mov %dl, KA2PA(vesa_red_pos)
    110104                shr $8, %edx
    111                 mov %dl, KA2PA(bfb_red_size)
     105                mov %dl, KA2PA(vesa_red_mask)
    112106               
    113107                mov %esi, %edx
    114                 mov %dl, KA2PA(bfb_blue_pos)
     108                mov %dl, KA2PA(vesa_blue_pos)
     109                shr $8, %edx
     110                mov %dl, KA2PA(vesa_blue_mask)
    115111               
    116                 shr $8, %edx
    117                 mov %dl, KA2PA(bfb_blue_size)
    118                
    119                 mov %edi, KA2PA(bfb_addr)
     112                mov %edi, KA2PA(vesa_ph_addr)
    120113#endif

  • kernel/arch/ia32/src/boot/vesa_real.inc

    rb8b1e631 r07fd4cd1  
    304304                /*
    305305                 * Store mode parameters:
    306                  *  eax = bpp[16] scanline[16]
     306                 *  eax = bpp[8] scanline[16]
    307307                 *  ebx = width[16]  height[16]
    308308                 *  edx = red_mask[8] red_pos[8] green_mask[8] green_pos[8]
    … …  
    328328                shl $8, %edx
    329329                mov VESA_MODE_RED_POS_OFFSET(%di), %dl
    330                
    331330                shl $8, %edx
    332331                mov VESA_MODE_GREEN_MASK_OFFSET(%di), %dl
    … …  
    370369                mov $0x0003, %ax
    371370                int $0x10
    372                
    373                 xor %eax, %eax
    374                 xor %ebx, %ebx
    375                 xor %edx, %edx
    376371                mov $0xffffffff, %edi
    377                
     372                xor %ax, %ax
    378373                jz vesa_leave_real  /* force relative jump */
    379374
    … …  
    391386
    392387default_mode:
    393         .ascii STRING(CONFIG_BFB_MODE)
     388        .ascii STRING(CONFIG_VESA_MODE)
    394389        .ascii "-"
    395         .asciz STRING(CONFIG_BFB_BPP)
     390        .asciz STRING(CONFIG_VESA_BPP)
    396391        .fill 24
    397392

  • kernel/arch/ia32/src/ia32.c

    rb8b1e631 r07fd4cd1  
    4242
    4343#include <genarch/multiboot/multiboot.h>
    44 #include <genarch/multiboot/multiboot2.h>
    4544#include <genarch/drivers/legacy/ia32/io.h>
    4645#include <genarch/drivers/ega/ega.h>
    47 #include <genarch/fb/bfb.h>
     46#include <arch/drivers/vesa.h>
    4847#include <genarch/drivers/i8042/i8042.h>
    4948#include <genarch/kbrd/kbrd.h>
    … …  
    7776/** Perform ia32-specific initialization before main_bsp() is called.
    7877 *
    79  * @param signature Multiboot signature.
    80  * @param info      Multiboot information structure.
    81  *
    82  */
    83 void arch_pre_main(uint32_t signature, void *info)
     78 * @param signature Should contain the multiboot signature.
     79 * @param mi        Pointer to the multiboot information structure.
     80 */
     81void arch_pre_main(uint32_t signature, const multiboot_info_t *mi)
    8482{
    8583        /* Parse multiboot information obtained from the bootloader. */
    86         multiboot_info_parse(signature, (multiboot_info_t *) info);
    87         multiboot2_info_parse(signature, (multiboot2_info_t *) info);
     84        multiboot_info_parse(signature, mi);
    8885       
    8986#ifdef CONFIG_SMP
    … …  
    117114               
    118115#if (defined(CONFIG_FB) || defined(CONFIG_EGA))
    119                 bool bfb = false;
     116                bool vesa = false;
    120117#endif
    121118               
    122119#ifdef CONFIG_FB
    123                 bfb = bfb_init();
     120                vesa = vesa_init();
    124121#endif
    125122               
    126123#ifdef CONFIG_EGA
    127                 if (!bfb) {
     124                if (!vesa) {
    128125                        outdev_t *egadev = ega_init(EGA_BASE, EGA_VIDEORAM);
    129126                        if (egadev)

  • kernel/genarch/Makefile.inc

    rb8b1e631 r07fd4cd1  
    6767                genarch/src/fb/font-8x16.c \
    6868                genarch/src/fb/logo-196x66.c \
    69                 genarch/src/fb/fb.c \
    70                 genarch/src/fb/bfb.c
     69                genarch/src/fb/fb.c
    7170endif
    7271
    … …  
    144143ifeq ($(CONFIG_MULTIBOOT), y)
    145144        GENARCH_SOURCES += \
    146                 genarch/src/multiboot/multiboot.c \
    147                 genarch/src/multiboot/multiboot2.c
     145                genarch/src/multiboot/multiboot.c
    148146endif
    149147

  • kernel/genarch/include/multiboot/multiboot.h

    rb8b1e631 r07fd4cd1  
    3636#define KERN_MULTIBOOT_H_
    3737
    38 #define MULTIBOOT_HEADER_MAGIC  0x1badb002
    39 #define MULTIBOOT_HEADER_FLAGS  0x00010003
    40 
    41 #define MULTIBOOT_LOADER_MAGIC  0x2badb002
    42 
    43 #ifndef __ASM__
    44 
    4538#include <typedefs.h>
    4639#include <arch/boot/memmap.h>
    47 
    48 /** Convert 32-bit multiboot address to a pointer. */
    49 #define MULTIBOOT_PTR(mba)  ((void *) (uintptr_t) (mba))
    5040
    5141/** Multiboot 32-bit address. */
    5242typedef uint32_t mbaddr_t;
    5343
    54 /** Multiboot module structure */
     44/** Multiboot mod structure */
    5545typedef struct {
    5646        mbaddr_t start;
    … …  
    5848        mbaddr_t string;
    5949        uint32_t reserved;
    60 } __attribute__((packed)) multiboot_module_t;
     50} __attribute__ ((packed)) multiboot_mod_t;
    6151
    6252/** Multiboot mmap structure */
    … …  
    6454        uint32_t size;
    6555        e820memmap_t mm_info;
    66 } __attribute__((packed)) multiboot_memmap_t;
     56} __attribute__ ((packed)) multiboot_mmap_t;
    6757
    6858/** Multiboot information structure */
    … …  
    8474       
    8575        /* ... */
    86 } __attribute__((packed)) multiboot_info_t;
     76} __attribute__ ((packed)) multiboot_info_t;
    8777
    8878enum multiboot_info_flags {
    89         MULTIBOOT_INFO_FLAGS_MEM     = 0x01,
    90         MULTIBOOT_INFO_FLAGS_BOOT    = 0x02,
    91         MULTIBOOT_INFO_FLAGS_CMDLINE = 0x04,
    92         MULTIBOOT_INFO_FLAGS_MODS    = 0x08,
    93         MULTIBOOT_INFO_FLAGS_SYMS1   = 0x10,
    94         MULTIBOOT_INFO_FLAGS_SYMS2   = 0x20,
    95         MULTIBOOT_INFO_FLAGS_MMAP    = 0x40
     79        MBINFO_FLAGS_MEM     = 0x01,
     80        MBINFO_FLAGS_BOOT    = 0x02,
     81        MBINFO_FLAGS_CMDLINE = 0x04,
     82        MBINFO_FLAGS_MODS    = 0x08,
     83        MBINFO_FLAGS_SYMS1   = 0x10,
     84        MBINFO_FLAGS_SYMS2   = 0x20,
     85        MBINFO_FLAGS_MMAP    = 0x40
    9686       
    9787        /* ... */
    9888};
    9989
    100 extern void multiboot_extract_command(char *, size_t, const char *);
     90#define MULTIBOOT_LOADER_MAGIC  0x2BADB002
     91
     92/** Convert 32-bit multiboot address to a pointer. */
     93#define MULTIBOOT_PTR(mba) ((void *)(uintptr_t) (mba))
     94
    10195extern void multiboot_info_parse(uint32_t, const multiboot_info_t *);
    102 
    103 #endif /* __ASM__ */
    10496
    10597#endif

  • kernel/genarch/src/multiboot/multiboot.c

    rb8b1e631 r07fd4cd1  
    3333 */
    3434
     35#include <genarch/multiboot/multiboot.h>
    3536#include <typedefs.h>
    36 #include <genarch/multiboot/multiboot.h>
    3737#include <config.h>
    3838#include <str.h>
     39#include <macros.h>
    3940
    4041/** Extract command name from the multiboot module command line.
    4142 *
    42  * @param buf      Destination buffer (will be always NULL-terminated).
    43  * @param size     Size of destination buffer (in bytes).
     43 * @param buf      Destination buffer (will always NULL-terminate).
     44 * @param sz       Size of destination buffer (in bytes).
    4445 * @param cmd_line Input string (the command line).
    4546 *
    4647 */
    47 void multiboot_extract_command(char *buf, size_t size, const char *cmd_line)
     48static void extract_command(char *buf, size_t sz, const char *cmd_line)
    4849{
    4950        /* Find the first space. */
    … …  
    6869       
    6970        /* Copy the command. */
    70         str_ncpy(buf, size, start, (size_t) (end - start));
    71 }
    72 
    73 static void multiboot_modules(uint32_t count, multiboot_module_t *mods)
    74 {
    75         for (uint32_t i = 0; i < count; i++) {
    76                 if (init.cnt >= CONFIG_INIT_TASKS)
    77                         break;
    78                
    79                 init.tasks[init.cnt].addr = PA2KA(mods[i].start);
    80                 init.tasks[init.cnt].size = mods[i].end - mods[i].start;
    81                
    82                 /* Copy command line, if available. */
    83                 if (mods[i].string) {
    84                         multiboot_extract_command(init.tasks[init.cnt].name,
    85                             CONFIG_TASK_NAME_BUFLEN, MULTIBOOT_PTR(mods[i].string));
    86                 } else
    87                         init.tasks[init.cnt].name[0] = 0;
    88                
    89                 init.cnt++;
    90         }
    91 }
    92 
    93 static void multiboot_memmap(uint32_t length, multiboot_memmap_t *memmap)
    94 {
    95         uint32_t pos = 0;
    96        
    97         while ((pos < length) && (e820counter < MEMMAP_E820_MAX_RECORDS)) {
    98                 e820table[e820counter] = memmap->mm_info;
    99                
    100                 /* Compute address of next structure. */
    101                 uint32_t size = sizeof(memmap->size) + memmap->size;
    102                 memmap = (multiboot_memmap_t *) ((uintptr_t) memmap + size);
    103                 pos += size;
    104                
    105                 e820counter++;
    106         }
     71        str_ncpy(buf, sz, start, (size_t) (end - start));
    10772}
    10873
    … …  
    11378 *
    11479 * @param signature Should contain the multiboot signature.
    115  * @param info      Multiboot information structure.
    116  *
     80 * @param mi        Pointer to the multiboot information structure.
    11781 */
    118 void multiboot_info_parse(uint32_t signature, const multiboot_info_t *info)
     82void multiboot_info_parse(uint32_t signature, const multiboot_info_t *mi)
    11983{
    120         if (signature != MULTIBOOT_LOADER_MAGIC)
    121                 return;
     84        uint32_t flags;
    12285       
    123         /* Copy modules information. */
    124         if ((info->flags & MULTIBOOT_INFO_FLAGS_MODS) != 0)
    125                 multiboot_modules(info->mods_count,
    126                     (multiboot_module_t *) MULTIBOOT_PTR(info->mods_addr));
     86        if (signature == MULTIBOOT_LOADER_MAGIC)
     87                flags = mi->flags;
     88        else {
     89                /* No multiboot info available. */
     90                flags = 0;
     91        }
     92       
     93        /* Copy module information. */
     94        uint32_t i;
     95        if ((flags & MBINFO_FLAGS_MODS) != 0) {
     96                init.cnt = min(mi->mods_count, CONFIG_INIT_TASKS);
     97                multiboot_mod_t *mods
     98                    = (multiboot_mod_t *) MULTIBOOT_PTR(mi->mods_addr);
     99               
     100                for (i = 0; i < init.cnt; i++) {
     101                        init.tasks[i].addr = PA2KA(mods[i].start);
     102                        init.tasks[i].size = mods[i].end - mods[i].start;
     103                       
     104                        /* Copy command line, if available. */
     105                        if (mods[i].string) {
     106                                extract_command(init.tasks[i].name,
     107                                    CONFIG_TASK_NAME_BUFLEN,
     108                                    MULTIBOOT_PTR(mods[i].string));
     109                        } else
     110                                init.tasks[i].name[0] = 0;
     111                }
     112        } else
     113                init.cnt = 0;
    127114       
    128115        /* Copy memory map. */
    129         if ((info->flags & MULTIBOOT_INFO_FLAGS_MMAP) != 0)
    130                 multiboot_memmap(info->mmap_length,
    131                     (multiboot_memmap_t *) MULTIBOOT_PTR(info->mmap_addr));
     116       
     117        if ((flags & MBINFO_FLAGS_MMAP) != 0) {
     118                int32_t mmap_length = mi->mmap_length;
     119                multiboot_mmap_t *mme = MULTIBOOT_PTR(mi->mmap_addr);
     120                e820counter = 0;
     121               
     122                i = 0;
     123                while ((mmap_length > 0) && (i < MEMMAP_E820_MAX_RECORDS)) {
     124                        e820table[i++] = mme->mm_info;
     125                       
     126                        /* Compute address of next structure. */
     127                        uint32_t size = sizeof(mme->size) + mme->size;
     128                        mme = ((void *) mme) + size;
     129                        mmap_length -= size;
     130                }
     131               
     132                e820counter = i;
     133        } else
     134                e820counter = 0;
    132135}
    133136

  • kernel/generic/include/lib/rd.h

    rb8b1e631 r07fd4cd1  
    3838#include <typedefs.h>
    3939
    40 extern void init_rd(void *, size_t);
     40/**
     41 * RAM disk version
     42 */
     43#define RD_VERSION      1
     44
     45/**
     46 * RAM disk magic number
     47 */
     48#define RD_MAGIC_SIZE   4
     49#define RD_MAG0                 'H'
     50#define RD_MAG1                 'O'
     51#define RD_MAG2                 'R'
     52#define RD_MAG3                 'D'
     53
     54/**
     55 * RAM disk data encoding types
     56 */
     57#define RD_DATA_NONE    0
     58#define RD_DATA_LSB             1               /* Least significant byte first (little endian) */
     59#define RD_DATA_MSB             2               /* Most signigicant byte first (big endian) */
     60
     61/**
     62 * RAM disk error return codes
     63 */
     64#define RE_OK                   0       /* No error */
     65#define RE_INVALID              1       /* Invalid RAM disk image */
     66#define RE_UNSUPPORTED          2       /* Non-supported image (e.g. wrong version) */
     67
     68/** RAM disk header */
     69struct rd_header {
     70        uint8_t magic[RD_MAGIC_SIZE];
     71        uint8_t version;
     72        uint8_t data_type;
     73        uint32_t header_size;
     74        uint64_t data_size;
     75} __attribute__ ((packed));
     76
     77typedef struct rd_header rd_header_t;
     78
     79extern int init_rd(rd_header_t *addr, size_t size);
    4180
    4281#endif

  • kernel/generic/src/lib/rd.c

    rb8b1e631 r07fd4cd1  
    3333/**
    3434 * @file
    35  * @brief RAM disk support.
     35 * @brief       RAM disk support.
    3636 *
    3737 * Support for RAM disk images.
    … …  
    3939
    4040#include <lib/rd.h>
     41#include <byteorder.h>
    4142#include <mm/frame.h>
    4243#include <sysinfo/sysinfo.h>
    4344#include <ddi/ddi.h>
     45#include <align.h>
    4446
    45 /** Physical memory area for RAM disk. */
    46 static parea_t rd_parea;
     47static parea_t rd_parea;                /**< Physical memory area for rd. */
    4748
    48 /** RAM disk initialization routine
    49  *
    50  * The information about the RAM disk is provided as sysinfo
    51  * values to the uspace tasks.
    52  *
    53  */
    54 void init_rd(void *data, size_t size)
     49/**
     50 * RAM disk initialization routine. At this point, the RAM disk memory is shared
     51 * and information about the share is provided as sysinfo values to the
     52 * userspace tasks.
     53 */ 
     54int init_rd(rd_header_t *header, size_t size)
    5555{
    56         uintptr_t base = KA2PA((uintptr_t) data);
    57         ASSERT((base % FRAME_SIZE) == 0);
     56        /* Identify RAM disk */
     57        if ((header->magic[0] != RD_MAG0) || (header->magic[1] != RD_MAG1) ||
     58            (header->magic[2] != RD_MAG2) || (header->magic[3] != RD_MAG3))
     59                return RE_INVALID;
    5860       
    59         rd_parea.pbase = base;
    60         rd_parea.frames = SIZE2FRAMES(size);
     61        /* Identify version */ 
     62        if (header->version != RD_VERSION)
     63                return RE_UNSUPPORTED;
     64       
     65        uint32_t hsize;
     66        uint64_t dsize;
     67        switch (header->data_type) {
     68        case RD_DATA_LSB:
     69                hsize = uint32_t_le2host(header->header_size);
     70                dsize = uint64_t_le2host(header->data_size);
     71                break;
     72        case RD_DATA_MSB:
     73                hsize = uint32_t_be2host(header->header_size);
     74                dsize = uint64_t_be2host(header->data_size);
     75                break;
     76        default:
     77                return RE_UNSUPPORTED;
     78        }
     79       
     80        if ((hsize % FRAME_SIZE) || (dsize % FRAME_SIZE))
     81                return RE_UNSUPPORTED;
     82               
     83        if (hsize > size)
     84                return RE_INVALID;
     85       
     86        if ((uint64_t) hsize + dsize > size)
     87                dsize = size - hsize;
     88       
     89        rd_parea.pbase = ALIGN_DOWN((uintptr_t) KA2PA((void *) header + hsize),
     90            FRAME_SIZE);
     91        rd_parea.frames = SIZE2FRAMES(dsize);
    6192        rd_parea.unpriv = false;
    6293        rd_parea.mapped = false;
    6394        ddi_parea_register(&rd_parea);
    64        
     95
    6596        sysinfo_set_item_val("rd", NULL, true);
    66         sysinfo_set_item_val("rd.size", NULL, size);
    67         sysinfo_set_item_val("rd.address.physical", NULL, (sysarg_t) base);
     97        sysinfo_set_item_val("rd.header_size", NULL, hsize);   
     98        sysinfo_set_item_val("rd.size", NULL, dsize);
     99        sysinfo_set_item_val("rd.address.physical", NULL,
     100            (sysarg_t) KA2PA((void *) header + hsize));
     101
     102        return RE_OK;
    68103}
    69104

  • kernel/generic/src/main/kinit.c

    rb8b1e631 r07fd4cd1  
    179179        for (i = 0; i < init.cnt; i++) {
    180180                if (init.tasks[i].addr % FRAME_SIZE) {
    181                         printf("init[%zu]: Address is not frame aligned\n", i);
     181                        printf("init[%zu].addr is not frame aligned\n", i);
    182182                        programs[i].task = NULL;
    183183                        continue;
    … …  
    203203                    namebuf, &programs[i]);
    204204               
    205                 if (rc == 0) {
    206                         if (programs[i].task != NULL) {
    207                                 /*
    208                                  * Set capabilities to init userspace tasks.
    209                                  */
    210                                 cap_set(programs[i].task, CAP_CAP | CAP_MEM_MANAGER |
    211                                     CAP_IO_MANAGER | CAP_IRQ_REG);
    212                                
    213                                 if (!ipc_phone_0)
    214                                         ipc_phone_0 = &programs[i].task->answerbox;
    215                         }
     205                if ((rc == 0) && (programs[i].task != NULL)) {
     206                        /*
     207                         * Set capabilities to init userspace tasks.
     208                         */
     209                        cap_set(programs[i].task, CAP_CAP | CAP_MEM_MANAGER |
     210                            CAP_IO_MANAGER | CAP_IRQ_REG);
    216211                       
    217                         /*
    218                          * If programs[i].task == NULL then it is
    219                          * the program loader and it was registered
    220                          * successfully.
    221                          */
    222                 } else if (i == init.cnt - 1) {
    223                         /*
    224                          * Assume the last task is the RAM disk.
    225                          */
    226                         init_rd((void *) init.tasks[i].addr, init.tasks[i].size);
    227                 } else
    228                         printf("init[%zu]: Init binary load failed (error %d)\n", i, rc);
     212                        if (!ipc_phone_0)
     213                                ipc_phone_0 = &programs[i].task->answerbox;
     214                } else if (rc == 0) {
     215                        /* It was the program loader and was registered */
     216                } else {
     217                        /* RAM disk image */
     218                        int rd = init_rd((rd_header_t *) init.tasks[i].addr, init.tasks[i].size);
     219                       
     220                        if (rd != RE_OK)
     221                                printf("Init binary %zu not used (error %d)\n", i, rd);
     222                }
    229223        }
    230224       

  • tools/config.py

    rb8b1e631 r07fd4cd1  
    8585        if ctype == 'cnf':
    8686                return True
    87        
    8887        return False
    8988
    … …  
    243242               
    244243                default = get_default_rule(rule)
    245                
     244
    246245                #
    247246                # If we don't have a value but we do have
    … …  
    345344        return True
    346345
    347 def preprocess_config(config, rules):
    348         "Preprocess configuration"
    349        
    350         varname_mode = 'CONFIG_BFB_MODE'
    351         varname_width = 'CONFIG_BFB_WIDTH'
    352         varname_height = 'CONFIG_BFB_HEIGHT'
    353        
    354         if varname_mode in config:
    355                 mode = config[varname_mode].partition('x')
    356                
    357                 config[varname_width] = mode[0]
    358                 rules.append((varname_width, 'choice', 'Default framebuffer width', None, None))
    359                
    360                 config[varname_height] = mode[2]
    361                 rules.append((varname_height, 'choice', 'Default framebuffer height', None, None))
    362 
    363346def create_output(mkname, mcname, config, rules):
    364347        "Create output configuration"
    … …  
    521504        if (len(sys.argv) >= 3) and (sys.argv[2] == 'default'):
    522505                if (infer_verify_choices(config, rules)):
    523                         preprocess_config(config, rules)
    524506                        create_output(MAKEFILE, MACROS, config, rules)
    525507                        return 0
    … …  
    535517               
    536518                if (infer_verify_choices(config, rules)):
    537                         preprocess_config(config, rules)
    538519                        create_output(MAKEFILE, MACROS, config, rules)
    539520                        return 0
    … …  
    583564                               
    584565                                default = get_default_rule(rule)
    585                                
     566
    586567                                #
    587568                                # If we don't have a value but we do have
    … …  
    645626                xtui.screen_done(screen)
    646627       
    647         preprocess_config(config, rules)
    648628        create_output(MAKEFILE, MACROS, config, rules)
    649629        return 0

  • uspace/drv/bus/usb/ehci/Makefile

    rb8b1e631 r07fd4cd1  
    4242
    4343SOURCES = \
     44        hc_iface.c \
    4445        main.c \
    4546        pci.c

  • uspace/drv/bus/usb/ehci/main.c

    rb8b1e631 r07fd4cd1  
    4242#include <usb/ddfiface.h>
    4343#include <usb/debug.h>
    44 #include <usb/host/hcd.h>
    4544
    4645#include "pci.h"
    47 
    48 #define NAME "ehci"
     46#include "ehci.h"
    4947
    5048static int ehci_dev_add(ddf_dev_t *device);
    … …  
    5957};
    6058static ddf_dev_ops_t hc_ops = {
    61         .interfaces[USBHC_DEV_IFACE] = &hcd_iface,
     59        .interfaces[USBHC_DEV_IFACE] = &ehci_hc_iface,
    6260};
    6361
    … …  
    9795                return ENOMEM;
    9896        }
    99         hcd_t *ehci_hc = ddf_fun_data_alloc(hc_fun, sizeof(hcd_t));
    100         if (ehci_hc == NULL) {
    101                 usb_log_error("Failed to alloc generic HC driver.\n");
    102                 return ENOMEM;
    103         }
    104         /* High Speed, no bandwidth */
    105         hcd_init(ehci_hc, USB_SPEED_HIGH, 0, NULL);
    10697        hc_fun->ops = &hc_ops;
    10798

  • uspace/drv/bus/usb/usbmid/explore.c

    rb8b1e631 r07fd4cd1  
    5454 * @return Interface @p interface_no is already present in the list.
    5555 */
    56 static bool interface_in_list(const list_t *list, int interface_no)
     56static bool interface_in_list(list_t *list, int interface_no)
    5757{
    5858        list_foreach(*list, l) {

  • uspace/drv/bus/usb/usbmid/usbmid.c

    rb8b1e631 r07fd4cd1  
    4545
    4646/** Callback for DDF USB interface. */
    47 static int usb_iface_get_interface_impl(ddf_fun_t *fun, int *iface_no)
     47static int usb_iface_get_interface_impl(ddf_fun_t *fun, devman_handle_t handle,
     48    int *iface_no)
    4849{
    4950        assert(fun);
    … …  
    6364        .get_hc_handle = usb_iface_get_hc_handle_device_impl,
    6465        .get_my_address = usb_iface_get_my_address_forward_impl,
    65         .get_my_interface = usb_iface_get_interface_impl,
     66        .get_interface = usb_iface_get_interface_impl,
    6667};
    6768

  • uspace/drv/bus/usb/vhc/connhost.c

    rb8b1e631 r07fd4cd1  
    508508        .request_address = request_address,
    509509        .bind_address = bind_address,
    510         .get_handle = find_by_address,
     510        .find_by_address = find_by_address,
    511511        .release_address = release_address,
    512512

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

    rb8b1e631 r07fd4cd1  
    11/*
    22 * Copyright (c) 2010 Vojtech Horky
    3  * Copyright (c) 2011 Jan Vesely
    43 * All rights reserved.
    54 *
    … …  
    4039#include "ddf/driver.h"
    4140
    42 typedef enum {
    43         IPC_M_USB_GET_MY_ADDRESS,
    44         IPC_M_USB_GET_MY_INTERFACE,
    45         IPC_M_USB_GET_HOST_CONTROLLER_HANDLE,
    46 } usb_iface_funcs_t;
    47 
    48 /** Tell USB address assigned to device.
    49  * @param exch Vaid IPC exchange
    50  * @param address Pointer to address storage place.
    51  * @return Error code.
    52  *
    53  * Exch param is an open communication to device implementing usb_iface.
    54  */
    55 int usb_get_my_address(async_exch_t *exch, usb_address_t *address)
    56 {
    57         if (!exch)
    58                 return EINVAL;
    59         sysarg_t addr;
    60         const int ret = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
    61             IPC_M_USB_GET_MY_ADDRESS, &addr);
    62 
    63         if (ret == EOK && address != NULL)
    64                 *address = (usb_address_t) addr;
    65         return ret;
    66 }
    67 /*----------------------------------------------------------------------------*/
    68 /** Tell interface number given device can use.
    69  * @param[in] exch IPC communication exchange
    70  * @param[in] handle Id of the device
    71  * @param[out] usb_iface Assigned USB interface
    72  * @return Error code.
    73  */
    74 int usb_get_my_interface(async_exch_t *exch, int *usb_iface)
    75 {
    76         if (!exch)
    77                 return EINVAL;
    78         sysarg_t iface_no;
    79         const int ret = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
    80             IPC_M_USB_GET_MY_INTERFACE, &iface_no);
    81         if (ret == EOK && usb_iface)
    82                 *usb_iface = (int)iface_no;
    83         return ret;
    84 }
    85 /*----------------------------------------------------------------------------*/
    86 /** Tell devman handle of device host controller.
    87  * @param[in] exch IPC communication exchange
    88  * @param[out] hc_handle devman handle of the HC used by the target device.
    89  * @return Error code.
    90  */
    91 int usb_get_hc_handle(async_exch_t *exch, devman_handle_t *hc_handle)
    92 {
    93         if (!exch)
    94                 return EINVAL;
    95         devman_handle_t h;
    96         const int ret = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
    97             IPC_M_USB_GET_HOST_CONTROLLER_HANDLE, &h);
    98         if (ret == EOK && hc_handle)
    99                 *hc_handle = (devman_handle_t)h;
    100         return ret;
    101 }
    102 
    10341
    10442static void remote_usb_get_my_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    105 static void remote_usb_get_my_interface(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     43static void remote_usb_get_interface(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    10644static void remote_usb_get_hc_handle(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     45//static void remote_usb(device_t *, void *, ipc_callid_t, ipc_call_t *);
    10746
    10847/** Remote USB interface operations. */
    10948static remote_iface_func_ptr_t remote_usb_iface_ops [] = {
    11049        [IPC_M_USB_GET_MY_ADDRESS] = remote_usb_get_my_address,
    111         [IPC_M_USB_GET_MY_INTERFACE] = remote_usb_get_my_interface,
     50        [IPC_M_USB_GET_INTERFACE] = remote_usb_get_interface,
    11251        [IPC_M_USB_GET_HOST_CONTROLLER_HANDLE] = remote_usb_get_hc_handle,
    11352};
    … …  
    12160};
    12261
    123 /*----------------------------------------------------------------------------*/
     62
    12463void remote_usb_get_my_address(ddf_fun_t *fun, void *iface,
    12564    ipc_callid_t callid, ipc_call_t *call)
    12665{
    127         const usb_iface_t *usb_iface = (usb_iface_t *) iface;
     66        usb_iface_t *usb_iface = (usb_iface_t *) iface;
    12867
    12968        if (usb_iface->get_my_address == NULL) {
    … …  
    13372
    13473        usb_address_t address;
    135         const int ret = usb_iface->get_my_address(fun, &address);
    136         if (ret != EOK) {
    137                 async_answer_0(callid, ret);
     74        int rc = usb_iface->get_my_address(fun, &address);
     75        if (rc != EOK) {
     76                async_answer_0(callid, rc);
    13877        } else {
    13978                async_answer_1(callid, EOK, address);
    14079        }
    14180}
    142 /*----------------------------------------------------------------------------*/
    143 void remote_usb_get_my_interface(ddf_fun_t *fun, void *iface,
     81
     82void remote_usb_get_interface(ddf_fun_t *fun, void *iface,
    14483    ipc_callid_t callid, ipc_call_t *call)
    14584{
    146         const usb_iface_t *usb_iface = (usb_iface_t *) iface;
     85        usb_iface_t *usb_iface = (usb_iface_t *) iface;
    14786
    148         if (usb_iface->get_my_interface == NULL) {
     87        if (usb_iface->get_interface == NULL) {
    14988                async_answer_0(callid, ENOTSUP);
    15089                return;
    15190        }
    15291
     92        devman_handle_t handle = DEV_IPC_GET_ARG1(*call);
     93
    15394        int iface_no;
    154         const int ret = usb_iface->get_my_interface(fun, &iface_no);
    155         if (ret != EOK) {
    156                 async_answer_0(callid, ret);
     95        int rc = usb_iface->get_interface(fun, handle, &iface_no);
     96        if (rc != EOK) {
     97                async_answer_0(callid, rc);
    15798        } else {
    15899                async_answer_1(callid, EOK, iface_no);
    159100        }
    160101}
    161 /*----------------------------------------------------------------------------*/
     102
    162103void remote_usb_get_hc_handle(ddf_fun_t *fun, void *iface,
    163104    ipc_callid_t callid, ipc_call_t *call)
    164105{
    165         const usb_iface_t *usb_iface = (usb_iface_t *) iface;
     106        usb_iface_t *usb_iface = (usb_iface_t *) iface;
    166107
    167108        if (usb_iface->get_hc_handle == NULL) {
    … …  
    171112
    172113        devman_handle_t handle;
    173         const int ret = usb_iface->get_hc_handle(fun, &handle);
    174         if (ret != EOK) {
    175                 async_answer_0(callid, ret);
     114        int rc = usb_iface->get_hc_handle(fun, &handle);
     115        if (rc != EOK) {
     116                async_answer_0(callid, rc);
    176117        }
    177118
    178119        async_answer_1(callid, EOK, (sysarg_t) handle);
    179120}
     121
     122
     123
    180124/**
    181125 * @}

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

    rb8b1e631 r07fd4cd1  
    11/*
    22 * Copyright (c) 2010-2011 Vojtech Horky
    3  * Copyright (c) 2011 Jan Vesely
    43 * All rights reserved.
    54 *
    … …  
    4342#define USB_MAX_PAYLOAD_SIZE 1020
    4443
    45 /** IPC methods for communication with HC through DDF interface.
    46  *
    47  * Notes for async methods:
    48  *
    49  * Methods for sending data to device (OUT transactions)
    50  * - e.g. IPC_M_USBHC_INTERRUPT_OUT -
    51  * always use the same semantics:
    52  * - first, IPC call with given method is made
    53  *   - argument #1 is target address
    54  *   - argument #2 is target endpoint
    55  *   - argument #3 is max packet size of the endpoint
    56  * - this call is immediately followed by IPC data write (from caller)
    57  * - the initial call (and the whole transaction) is answer after the
    58  *   transaction is scheduled by the HC and acknowledged by the device
    59  *   or immediately after error is detected
    60  * - the answer carries only the error code
    61  *
    62  * Methods for retrieving data from device (IN transactions)
    63  * - e.g. IPC_M_USBHC_INTERRUPT_IN -
    64  * also use the same semantics:
    65  * - first, IPC call with given method is made
    66  *   - argument #1 is target address
    67  *   - argument #2 is target endpoint
    68  * - this call is immediately followed by IPC data read (async version)
    69  * - the call is not answered until the device returns some data (or until
    70  *   error occurs)
    71  *
    72  * Some special methods (NO-DATA transactions) do not send any data. These
    73  * might behave as both OUT or IN transactions because communication parts
    74  * where actual buffers are exchanged are omitted.
    75  **
    76  * For all these methods, wrap functions exists. Important rule: functions
    77  * for IN transactions have (as parameters) buffers where retrieved data
    78  * will be stored. These buffers must be already allocated and shall not be
    79  * touch until the transaction is completed
    80  * (e.g. not before calling usb_wait_for() with appropriate handle).
    81  * OUT transactions buffers can be freed immediately after call is dispatched
    82  * (i.e. after return from wrapping function).
    83  *
    84  */
    85 typedef enum {
    86         /** Asks for address assignment by host controller.
    87          * Answer:
    88          * - ELIMIT - host controller run out of address
    89          * - EOK - address assigned
    90          * Answer arguments:
    91          * - assigned address
    92          *
    93          * The address must be released by via IPC_M_USBHC_RELEASE_ADDRESS.
    94          */
    95         IPC_M_USBHC_REQUEST_ADDRESS,
    96 
    97         /** Bind USB address with devman handle.
    98          * Parameters:
    99          * - USB address
    100          * - devman handle
    101          * Answer:
    102          * - EOK - address binded
    103          * - ENOENT - address is not in use
    104          */
    105         IPC_M_USBHC_BIND_ADDRESS,
    106 
    107         /** Get handle binded with given USB address.
    108          * Parameters
    109          * - USB address
    110          * Answer:
    111          * - EOK - address binded, first parameter is the devman handle
    112          * - ENOENT - address is not in use at the moment
    113          */
    114         IPC_M_USBHC_GET_HANDLE_BY_ADDRESS,
    115 
    116         /** Release address in use.
    117          * Arguments:
    118          * - address to be released
    119          * Answer:
    120          * - ENOENT - address not in use
    121          * - EPERM - trying to release default USB address
    122          */
    123         IPC_M_USBHC_RELEASE_ADDRESS,
    124 
    125         /** Register endpoint attributes at host controller.
    126          * This is used to reserve portion of USB bandwidth.
    127          * When speed is invalid, speed of the device is used.
    128          * Parameters:
    129          * - USB address + endpoint number
    130          *   - packed as ADDR << 16 + EP
    131          * - speed + transfer type + direction
    132          *   - packed as ( SPEED << 8 + TYPE ) << 8 + DIR
    133          * - maximum packet size + interval (in milliseconds)
    134          *   - packed as MPS << 16 + INT
    135          * Answer:
    136          * - EOK - reservation successful
    137          * - ELIMIT - not enough bandwidth to satisfy the request
    138          */
    139         IPC_M_USBHC_REGISTER_ENDPOINT,
    140 
    141         /** Revert endpoint registration.
    142          * Parameters:
    143          * - USB address
    144          * - endpoint number
    145          * - data direction
    146          * Answer:
    147          * - EOK - endpoint unregistered
    148          * - ENOENT - unknown endpoint
    149          */
    150         IPC_M_USBHC_UNREGISTER_ENDPOINT,
    151 
    152         /** Get data from device.
    153          * See explanation at usb_iface_funcs_t (IN transaction).
    154          */
    155         IPC_M_USBHC_READ,
    156 
    157         /** Send data to device.
    158          * See explanation at usb_iface_funcs_t (OUT transaction).
    159          */
    160         IPC_M_USBHC_WRITE,
    161 } usbhc_iface_funcs_t;
    162 
    163 int usbhc_request_address(async_exch_t *exch, usb_address_t *address,
    164     bool strict, usb_speed_t speed)
    165 {
    166         if (!exch || !address)
    167                 return EINVAL;
    168         sysarg_t new_address;
    169         const int ret = async_req_4_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    170             IPC_M_USBHC_REQUEST_ADDRESS, *address, strict, speed, &new_address);
    171         if (ret == EOK)
    172                 *address = (usb_address_t)new_address;
    173         return ret;
    174 }
    175 /*----------------------------------------------------------------------------*/
    176 int usbhc_bind_address(async_exch_t *exch, usb_address_t address,
    177     devman_handle_t handle)
    178 {
    179         if (!exch)
    180                 return EINVAL;
    181         return async_req_3_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    182             IPC_M_USBHC_BIND_ADDRESS, address, handle);
    183 }
    184 /*----------------------------------------------------------------------------*/
    185 int usbhc_get_handle(async_exch_t *exch, usb_address_t address,
    186     devman_handle_t *handle)
    187 {
    188         if (!exch)
    189                 return EINVAL;
    190         sysarg_t h;
    191         const int ret = async_req_2_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    192             IPC_M_USBHC_GET_HANDLE_BY_ADDRESS, address, &h);
    193         if (ret == EOK && handle)
    194                 *handle = (devman_handle_t)h;
    195         return ret;
    196 }
    197 /*----------------------------------------------------------------------------*/
    198 int usbhc_release_address(async_exch_t *exch, usb_address_t address)
    199 {
    200         if (!exch)
    201                 return EINVAL;
    202         return async_req_2_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    203             IPC_M_USBHC_RELEASE_ADDRESS, address);
    204 }
    205 /*----------------------------------------------------------------------------*/
    206 int usbhc_register_endpoint(async_exch_t *exch, usb_address_t address,
    207     usb_endpoint_t endpoint, usb_transfer_type_t type,
    208     usb_direction_t direction, size_t mps, unsigned interval)
    209 {
    210         if (!exch)
    211                 return EINVAL;
    212         const usb_target_t target =
    213             {{ .address = address, .endpoint = endpoint }};
    214 #define _PACK2(high, low) (((high & 0xffff) << 16) | (low & 0xffff))
    215 
    216         return async_req_4_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    217             IPC_M_USBHC_REGISTER_ENDPOINT, target.packed,
    218             _PACK2(type, direction), _PACK2(mps, interval));
    219 
    220 #undef _PACK2
    221 }
    222 /*----------------------------------------------------------------------------*/
    223 int usbhc_unregister_endpoint(async_exch_t *exch, usb_address_t address,
    224     usb_endpoint_t endpoint, usb_direction_t direction)
    225 {
    226         if (!exch)
    227                 return EINVAL;
    228         return async_req_4_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    229             IPC_M_USBHC_UNREGISTER_ENDPOINT, address, endpoint, direction);
    230 }
    231 /*----------------------------------------------------------------------------*/
    232 int usbhc_read(async_exch_t *exch, usb_address_t address,
    233     usb_endpoint_t endpoint, uint64_t setup, void *data, size_t size,
    234     size_t *rec_size)
    235 {
    236         if (size == 0 && setup == 0)
    237                 return EOK;
    238 
    239         if (!exch)
    240                 return EINVAL;
    241         const usb_target_t target =
    242             {{ .address = address, .endpoint = endpoint }};
    243 
    244         /* Make call identifying target USB device and type of transfer. */
    245         aid_t opening_request = async_send_4(exch,
    246             DEV_IFACE_ID(USBHC_DEV_IFACE),
    247             IPC_M_USBHC_READ, target.packed,
    248             (setup & UINT32_MAX), (setup >> 32), NULL);
    249 
    250         if (opening_request == 0) {
    251                 return ENOMEM;
    252         }
    253 
    254         /* Retrieve the data. */
    255         ipc_call_t data_request_call;
    256         aid_t data_request =
    257             async_data_read(exch, data, size, &data_request_call);
    258 
    259         if (data_request == 0) {
    260                 // FIXME: How to let the other side know that we want to abort?
    261                 async_wait_for(opening_request, NULL);
    262                 return ENOMEM;
    263         }
    264 
    265         /* Wait for the answer. */
    266         sysarg_t data_request_rc;
    267         sysarg_t opening_request_rc;
    268         async_wait_for(data_request, &data_request_rc);
    269         async_wait_for(opening_request, &opening_request_rc);
    270 
    271         if (data_request_rc != EOK) {
    272                 /* Prefer the return code of the opening request. */
    273                 if (opening_request_rc != EOK) {
    274                         return (int) opening_request_rc;
    275                 } else {
    276                         return (int) data_request_rc;
    277                 }
    278         }
    279         if (opening_request_rc != EOK) {
    280                 return (int) opening_request_rc;
    281         }
    282 
    283         *rec_size = IPC_GET_ARG2(data_request_call);
    284         return EOK;
    285 }
    286 /*----------------------------------------------------------------------------*/
    287 int usbhc_write(async_exch_t *exch, usb_address_t address,
    288     usb_endpoint_t endpoint, uint64_t setup, const void *data, size_t size)
    289 {
    290         if (size == 0 && setup == 0)
    291                 return EOK;
    292 
    293         if (!exch)
    294                 return EINVAL;
    295         const usb_target_t target =
    296             {{ .address = address, .endpoint = endpoint }};
    297 
    298         aid_t opening_request = async_send_5(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
    299             IPC_M_USBHC_WRITE, target.packed, size,
    300             (setup & UINT32_MAX), (setup >> 32), NULL);
    301 
    302         if (opening_request == 0) {
    303                 return ENOMEM;
    304         }
    305 
    306         /* Send the data if any. */
    307         if (size > 0) {
    308                 const int ret = async_data_write_start(exch, data, size);
    309                 if (ret != EOK) {
    310                         async_wait_for(opening_request, NULL);
    311                         return ret;
    312                 }
    313         }
    314 
    315         /* Wait for the answer. */
    316         sysarg_t opening_request_rc;
    317         async_wait_for(opening_request, &opening_request_rc);
    318 
    319         return (int) opening_request_rc;
    320 }
    321 /*----------------------------------------------------------------------------*/
    322 
    32344static void remote_usbhc_request_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    32445static void remote_usbhc_bind_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    325 static void remote_usbhc_get_handle(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
     46static void remote_usbhc_find_by_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    32647static void remote_usbhc_release_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    32748static void remote_usbhc_register_endpoint(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
    … …  
    33657        [IPC_M_USBHC_RELEASE_ADDRESS] = remote_usbhc_release_address,
    33758        [IPC_M_USBHC_BIND_ADDRESS] = remote_usbhc_bind_address,
    338         [IPC_M_USBHC_GET_HANDLE_BY_ADDRESS] = remote_usbhc_get_handle,
     59        [IPC_M_USBHC_GET_HANDLE_BY_ADDRESS] = remote_usbhc_find_by_address,
    33960
    34061        [IPC_M_USBHC_REGISTER_ENDPOINT] = remote_usbhc_register_endpoint,
    … …  
    35778        ipc_callid_t data_caller;
    35879        void *buffer;
     80        size_t size;
    35981} async_transaction_t;
    36082
    … …  
    381103        trans->data_caller = 0;
    382104        trans->buffer = NULL;
     105        trans->size = 0;
    383106
    384107        return trans;
    385108}
    386 /*----------------------------------------------------------------------------*/
     109
    387110void remote_usbhc_request_address(ddf_fun_t *fun, void *iface,
    388111    ipc_callid_t callid, ipc_call_t *call)
    389112{
    390         const usbhc_iface_t *usb_iface = iface;
     113        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    391114
    392115        if (!usb_iface->request_address) {
    … …  
    406129        }
    407130}
    408 /*----------------------------------------------------------------------------*/
     131
    409132void remote_usbhc_bind_address(ddf_fun_t *fun, void *iface,
    410133    ipc_callid_t callid, ipc_call_t *call)
    411134{
    412         const usbhc_iface_t *usb_iface = iface;
     135        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    413136
    414137        if (!usb_iface->bind_address) {
    … …  
    417140        }
    418141
    419         const usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
    420         const devman_handle_t handle = (devman_handle_t) DEV_IPC_GET_ARG2(*call);
    421 
    422         const int ret = usb_iface->bind_address(fun, address, handle);
    423         async_answer_0(callid, ret);
    424 }
    425 /*----------------------------------------------------------------------------*/
    426 void remote_usbhc_get_handle(ddf_fun_t *fun, void *iface,
    427     ipc_callid_t callid, ipc_call_t *call)
    428 {
    429         const usbhc_iface_t *usb_iface = iface;
    430 
    431         if (!usb_iface->get_handle) {
    432                 async_answer_0(callid, ENOTSUP);
    433                 return;
    434         }
    435 
    436         const usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
     142        usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
     143        devman_handle_t handle = (devman_handle_t) DEV_IPC_GET_ARG2(*call);
     144
     145        int rc = usb_iface->bind_address(fun, address, handle);
     146
     147        async_answer_0(callid, rc);
     148}
     149
     150void remote_usbhc_find_by_address(ddf_fun_t *fun, void *iface,
     151    ipc_callid_t callid, ipc_call_t *call)
     152{
     153        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
     154
     155        if (!usb_iface->find_by_address) {
     156                async_answer_0(callid, ENOTSUP);
     157                return;
     158        }
     159
     160        usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
    437161        devman_handle_t handle;
    438         const int ret = usb_iface->get_handle(fun, address, &handle);
    439 
    440         if (ret == EOK) {
    441                 async_answer_1(callid, ret, handle);
     162        int rc = usb_iface->find_by_address(fun, address, &handle);
     163
     164        if (rc == EOK) {
     165                async_answer_1(callid, EOK, handle);
    442166        } else {
    443                 async_answer_0(callid, ret);
    444         }
    445 }
    446 /*----------------------------------------------------------------------------*/
     167                async_answer_0(callid, rc);
     168        }
     169}
     170
    447171void remote_usbhc_release_address(ddf_fun_t *fun, void *iface,
    448172    ipc_callid_t callid, ipc_call_t *call)
    449173{
    450         const usbhc_iface_t *usb_iface = iface;
     174        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
    451175
    452176        if (!usb_iface->release_address) {
    … …  
    455179        }
    456180
    457         const usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
    458 
    459         const int ret = usb_iface->release_address(fun, address);
    460         async_answer_0(callid, ret);
    461 }
    462 /*----------------------------------------------------------------------------*/
     181        usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
     182
     183        int rc = usb_iface->release_address(fun, address);
     184
     185        async_answer_0(callid, rc);
     186}
     187
     188
    463189static void callback_out(ddf_fun_t *fun,
    464190    int outcome, void *arg)
    465191{
    466         async_transaction_t *trans = arg;
     192        async_transaction_t *trans = (async_transaction_t *)arg;
    467193
    468194        async_answer_0(trans->caller, outcome);
    … …  
    470196        async_transaction_destroy(trans);
    471197}
    472 /*----------------------------------------------------------------------------*/
     198
    473199static void callback_in(ddf_fun_t *fun,
    474200    int outcome, size_t actual_size, void *arg)
    … …  
    485211        }
    486212
     213        trans->size = actual_size;
     214
    487215        if (trans->data_caller) {
    488216                async_data_read_finalize(trans->data_caller,
    … …  
    494222        async_transaction_destroy(trans);
    495223}
    496 /*----------------------------------------------------------------------------*/
     224
    497225void remote_usbhc_register_endpoint(ddf_fun_t *fun, void *iface,
    498226    ipc_callid_t callid, ipc_call_t *call)
    … …  
    572300        }
    573301
    574         size_t size = 0;
    575         if (!async_data_read_receive(&trans->data_caller, &size)) {
     302        if (!async_data_read_receive(&trans->data_caller, &trans->size)) {
    576303                async_answer_0(callid, EPARTY);
    577304                return;
    578305        }
    579306
    580         trans->buffer = malloc(size);
     307        trans->buffer = malloc(trans->size);
    581308        if (trans->buffer == NULL) {
    582309                async_answer_0(trans->data_caller, ENOMEM);
    … …  
    586313
    587314        const int rc = hc_iface->read(
    588             fun, target, setup, trans->buffer, size, callback_in, trans);
     315            fun, target, setup, trans->buffer, trans->size, callback_in, trans);
    589316
    590317        if (rc != EOK) {
    … …  
    594321        }
    595322}
    596 /*----------------------------------------------------------------------------*/
     323
    597324void remote_usbhc_write(
    598325    ddf_fun_t *fun, void *iface, ipc_callid_t callid, ipc_call_t *call)
    … …  
    621348        }
    622349
    623         size_t size = 0;
    624350        if (data_buffer_len > 0) {
    625                 const int rc = async_data_write_accept(&trans->buffer, false,
     351                int rc = async_data_write_accept(&trans->buffer, false,
    626352                    1, USB_MAX_PAYLOAD_SIZE,
    627                     0, &size);
     353                    0, &trans->size);
    628354
    629355                if (rc != EOK) {
    … …  
    634360        }
    635361
    636         const int rc = hc_iface->write(
    637             fun, target, setup, trans->buffer, size, callback_out, trans);
     362        int rc = hc_iface->write(
     363            fun, target, setup, trans->buffer, trans->size, callback_out, trans);
    638364
    639365        if (rc != EOK) {
    … …  
    642368        }
    643369}
     370
     371
    644372/**
    645373 * @}

  • uspace/lib/drv/include/usb_iface.h

    rb8b1e631 r07fd4cd1  
    3939
    4040#include "ddf/driver.h"
    41 #include <async.h>
    4241#include <usb/usb.h>
     42typedef enum {
     43        /** Tell USB address assigned to device.
     44         * Parameters:
     45         * - devman handle id
     46         * Answer:
     47         * - EINVAL - unknown handle or handle not managed by this driver
     48         * - ENOTSUP - operation not supported (shall not happen)
     49         * - arbitrary error code if returned by remote implementation
     50         * - EOK - handle found, first parameter contains the USB address
     51         *
     52         * The handle must be the one used for binding USB address with
     53         * it (IPC_M_USBHC_BIND_ADDRESS), otherwise the host controller
     54         * (that this request would eventually reach) would not be able
     55         * to find it.
     56         * The problem is that this handle is actually assigned to the
     57         * function inside driver of the parent device (usually hub driver).
     58         * To bypass this problem, the initial caller specify handle as
     59         * zero and the first parent assigns the actual value.
     60         * See usb_iface_get_address_hub_child_impl() implementation
     61         * that could be assigned to device ops of a child device of in a
     62         * hub driver.
     63         * For example, the USB multi interface device driver (MID)
     64         * passes this initial zero without any modification because the
     65         * handle must be resolved by its parent.
     66         */
     67        IPC_M_USB_GET_MY_ADDRESS,
    4368
    44 int usb_get_my_address(async_exch_t *, usb_address_t *);
    45 int usb_get_my_interface(async_exch_t *, int *);
    46 int usb_get_hc_handle(async_exch_t *, devman_handle_t *);
     69        /** Tell interface number given device can use.
     70         * Parameters
     71         * - devman handle id of the device
     72         * Answer:
     73         * - ENOTSUP - operation not supported (can also mean any interface)
     74         * - EOK - operation okay, first parameter contains interface number
     75         */
     76        IPC_M_USB_GET_INTERFACE,
     77
     78        /** Tell devman handle of device host controller.
     79         * Parameters:
     80         * - none
     81         * Answer:
     82         * - EOK - request processed without errors
     83         * - ENOTSUP - this indicates invalid USB driver
     84         * Parameters of the answer:
     85         * - devman handle of HC caller is physically connected to
     86         */
     87        IPC_M_USB_GET_HOST_CONTROLLER_HANDLE
     88} usb_iface_funcs_t;
    4789
    4890/** USB device communication interface. */
    4991typedef struct {
    5092        int (*get_my_address)(ddf_fun_t *, usb_address_t *);
    51         int (*get_my_interface)(ddf_fun_t *, int *);
     93        int (*get_interface)(ddf_fun_t *, devman_handle_t, int *);
    5294        int (*get_hc_handle)(ddf_fun_t *, devman_handle_t *);
    5395} usb_iface_t;
     96
    5497
    5598#endif

  • uspace/lib/drv/include/usbhc_iface.h

    rb8b1e631 r07fd4cd1  
    4242#include <bool.h>
    4343
    44 int usbhc_request_address(async_exch_t *, usb_address_t *, bool, usb_speed_t);
    45 int usbhc_bind_address(async_exch_t *, usb_address_t, devman_handle_t);
    46 int usbhc_get_handle(async_exch_t *, usb_address_t, devman_handle_t *);
    47 int usbhc_release_address(async_exch_t *, usb_address_t);
    48 int usbhc_register_endpoint(async_exch_t *, usb_address_t,  usb_endpoint_t,
    49     usb_transfer_type_t, usb_direction_t, size_t, unsigned int);
    50 int usbhc_unregister_endpoint(async_exch_t *, usb_address_t, usb_endpoint_t,
    51     usb_direction_t);
    52 int usbhc_read(async_exch_t *, usb_address_t, usb_endpoint_t,
    53     uint64_t, void *, size_t, size_t *);
    54 int usbhc_write(async_exch_t *, usb_address_t, usb_endpoint_t,
    55     uint64_t, const void *, size_t);
     44
     45/** IPC methods for communication with HC through DDF interface.
     46 *
     47 * Notes for async methods:
     48 *
     49 * Methods for sending data to device (OUT transactions)
     50 * - e.g. IPC_M_USBHC_INTERRUPT_OUT -
     51 * always use the same semantics:
     52 * - first, IPC call with given method is made
     53 *   - argument #1 is target address
     54 *   - argument #2 is target endpoint
     55 *   - argument #3 is max packet size of the endpoint
     56 * - this call is immediately followed by IPC data write (from caller)
     57 * - the initial call (and the whole transaction) is answer after the
     58 *   transaction is scheduled by the HC and acknowledged by the device
     59 *   or immediately after error is detected
     60 * - the answer carries only the error code
     61 *
     62 * Methods for retrieving data from device (IN transactions)
     63 * - e.g. IPC_M_USBHC_INTERRUPT_IN -
     64 * also use the same semantics:
     65 * - first, IPC call with given method is made
     66 *   - argument #1 is target address
     67 *   - argument #2 is target endpoint
     68 * - this call is immediately followed by IPC data read (async version)
     69 * - the call is not answered until the device returns some data (or until
     70 *   error occurs)
     71 *
     72 * Some special methods (NO-DATA transactions) do not send any data. These
     73 * might behave as both OUT or IN transactions because communication parts
     74 * where actual buffers are exchanged are omitted.
     75 **
     76 * For all these methods, wrap functions exists. Important rule: functions
     77 * for IN transactions have (as parameters) buffers where retrieved data
     78 * will be stored. These buffers must be already allocated and shall not be
     79 * touch until the transaction is completed
     80 * (e.g. not before calling usb_wait_for() with appropriate handle).
     81 * OUT transactions buffers can be freed immediately after call is dispatched
     82 * (i.e. after return from wrapping function).
     83 *
     84 */
     85typedef enum {
     86        /** Asks for address assignment by host controller.
     87         * Answer:
     88         * - ELIMIT - host controller run out of address
     89         * - EOK - address assigned
     90         * Answer arguments:
     91         * - assigned address
     92         *
     93         * The address must be released by via IPC_M_USBHC_RELEASE_ADDRESS.
     94         */
     95        IPC_M_USBHC_REQUEST_ADDRESS,
     96
     97        /** Bind USB address with devman handle.
     98         * Parameters:
     99         * - USB address
     100         * - devman handle
     101         * Answer:
     102         * - EOK - address binded
     103         * - ENOENT - address is not in use
     104         */
     105        IPC_M_USBHC_BIND_ADDRESS,
     106
     107        /** Get handle binded with given USB address.
     108         * Parameters
     109         * - USB address
     110         * Answer:
     111         * - EOK - address binded, first parameter is the devman handle
     112         * - ENOENT - address is not in use at the moment
     113         */
     114        IPC_M_USBHC_GET_HANDLE_BY_ADDRESS,
     115
     116        /** Release address in use.
     117         * Arguments:
     118         * - address to be released
     119         * Answer:
     120         * - ENOENT - address not in use
     121         * - EPERM - trying to release default USB address
     122         */
     123        IPC_M_USBHC_RELEASE_ADDRESS,
     124
     125        /** Register endpoint attributes at host controller.
     126         * This is used to reserve portion of USB bandwidth.
     127         * When speed is invalid, speed of the device is used.
     128         * Parameters:
     129         * - USB address + endpoint number
     130         *   - packed as ADDR << 16 + EP
     131         * - speed + transfer type + direction
     132         *   - packed as ( SPEED << 8 + TYPE ) << 8 + DIR
     133         * - maximum packet size + interval (in milliseconds)
     134         *   - packed as MPS << 16 + INT
     135         * Answer:
     136         * - EOK - reservation successful
     137         * - ELIMIT - not enough bandwidth to satisfy the request
     138         */
     139        IPC_M_USBHC_REGISTER_ENDPOINT,
     140
     141        /** Revert endpoint registration.
     142         * Parameters:
     143         * - USB address
     144         * - endpoint number
     145         * - data direction
     146         * Answer:
     147         * - EOK - endpoint unregistered
     148         * - ENOENT - unknown endpoint
     149         */
     150        IPC_M_USBHC_UNREGISTER_ENDPOINT,
     151
     152        /** Get data from device.
     153         * See explanation at usb_iface_funcs_t (IN transaction).
     154         */
     155        IPC_M_USBHC_READ,
     156
     157        /** Send data to device.
     158         * See explanation at usb_iface_funcs_t (OUT transaction).
     159         */
     160        IPC_M_USBHC_WRITE,
     161} usbhc_iface_funcs_t;
    56162
    57163/** Callback for outgoing transfer. */
    … …  
    66172        int (*request_address)(ddf_fun_t *, usb_address_t *, bool, usb_speed_t);
    67173        int (*bind_address)(ddf_fun_t *, usb_address_t, devman_handle_t);
    68         int (*get_handle)(ddf_fun_t *, usb_address_t,
    69             devman_handle_t *);
     174        int (*find_by_address)(ddf_fun_t *, usb_address_t, devman_handle_t *);
    70175        int (*release_address)(ddf_fun_t *, usb_address_t);
    71176

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

    rb8b1e631 r07fd4cd1  
    3636#include <devman.h>
    3737#include <async.h>
    38 #include <usb_iface.h>
    3938#include <usb/ddfiface.h>
    4039#include <usb/hc.h>
    … …  
    105104
    106105        async_exch_t *exch = async_exchange_begin(parent_sess);
    107         if (!exch) {
    108                 async_hangup(parent_sess);
    109                 return ENOMEM;
    110         }
    111106
    112         const int ret = usb_get_my_address(exch, address);
     107        sysarg_t addr;
     108        int rc = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
     109            IPC_M_USB_GET_MY_ADDRESS, &addr);
    113110
    114111        async_exchange_end(exch);
    115112        async_hangup(parent_sess);
    116113
    117         return ret;
     114        if (rc != EOK)
     115                return rc;
     116
     117        if (address != NULL)
     118                *address = (usb_address_t) addr;
     119
     120        return EOK;
    118121}
    119122

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

    rb8b1e631 r07fd4cd1  
    153153        if (!usb_hc_connection_is_opened(connection))
    154154                return ENOENT;
    155 
     155       
    156156        async_exch_t *exch = async_exchange_begin(connection->hc_sess);
    157         if (!exch)
    158                 return ENOMEM;
    159         const int ret = usbhc_get_handle(exch, address, handle);
     157       
     158        sysarg_t tmp;
     159        int rc = async_req_2_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
     160            IPC_M_USBHC_GET_HANDLE_BY_ADDRESS,
     161            address, &tmp);
     162       
    160163        async_exchange_end(exch);
    161         return ret;
     164       
     165        if ((rc == EOK) && (handle != NULL))
     166                *handle = tmp;
     167       
     168        return rc;
    162169}
    163170
    … …  
    174181        if (!parent_sess)
    175182                return ENOMEM;
    176 
     183       
    177184        async_exch_t *exch = async_exchange_begin(parent_sess);
    178         if (!exch) {
    179                 async_hangup(parent_sess);
    180                 return ENOMEM;
    181         }
    182         usb_address_t address;
    183         const int ret = usb_get_my_address(exch, &address);
    184 
     185       
     186        sysarg_t address;
     187        int rc = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
     188            IPC_M_USB_GET_MY_ADDRESS, &address);
     189       
    185190        async_exchange_end(exch);
    186191        async_hangup(parent_sess);
    187 
    188         if (ret != EOK)
    189                 return ret;
    190 
    191         return address;
     192       
     193        if (rc != EOK)
     194                return rc;
     195       
     196        return (usb_address_t) address;
    192197}
    193198
    … …  
    226231        if (!parent_sess)
    227232                return ENOMEM;
    228 
     233       
    229234        async_exch_t *exch = async_exchange_begin(parent_sess);
    230         if (!exch) {
    231                 async_hangup(parent_sess);
    232                 return ENOMEM;
    233         }
    234         const int ret = usb_get_hc_handle(exch, hc_handle);
    235 
     235       
     236        devman_handle_t h;
     237        int rc = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
     238            IPC_M_USB_GET_HOST_CONTROLLER_HANDLE, &h);
     239       
    236240        async_exchange_end(exch);
    237241        async_hangup(parent_sess);
    238 
    239         return ret;
     242       
     243        if (rc != EOK)
     244                return rc;
     245       
     246        if (hc_handle != NULL)
     247                *hc_handle = h;
     248       
     249        return EOK;
    240250}
    241251

  • uspace/lib/usbdev/include/usb/dev/pipes.h

    rb8b1e631 r07fd4cd1  
    179179
    180180int usb_pipe_read(usb_pipe_t *, void *, size_t, size_t *);
    181 int usb_pipe_write(usb_pipe_t *, const void *, size_t);
     181int usb_pipe_write(usb_pipe_t *, void *, size_t);
    182182
    183183int usb_pipe_control_read(usb_pipe_t *, const void *, size_t,

  • uspace/lib/usbdev/include/usb/dev/request.h

    rb8b1e631 r07fd4cd1  
    8282         */
    8383        uint8_t request_type;
    84 #define SETUP_REQUEST_TYPE_DEVICE_TO_HOST (1 << 7)
    85 
    8684        /** Request identification. */
    8785        uint8_t request;

  • uspace/lib/usbdev/src/altiface.c

    rb8b1e631 r07fd4cd1  
    6565        size_t alternate_count = 0;
    6666
    67         const void *iface_ptr =
    68             usb_dp_get_nested_descriptor(&dp_parser, &dp_data, config_descr);
     67        const uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser,
     68            &dp_data, config_descr);
    6969        while (iface_ptr != NULL) {
    70                 const usb_standard_interface_descriptor_t *iface = iface_ptr;
    71                 if (iface->descriptor_type == USB_DESCTYPE_INTERFACE
    72                     && iface->interface_number == interface_no) {
    73                         ++alternate_count;
     70                usb_standard_interface_descriptor_t *iface
     71                    = (usb_standard_interface_descriptor_t *) iface_ptr;
     72                if (iface->descriptor_type == USB_DESCTYPE_INTERFACE) {
     73                        if (iface->interface_number == interface_no) {
     74                                alternate_count++;
     75                        }
    7476                }
    7577                iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser, &dp_data,
    … …  
    8082}
    8183
    82 /** Initialize alternate interface representation structure.
     84/** Create alternate interface representation structure.
    8385 *
    84  * @param[in] alternates Pointer to allocated structure.
    8586 * @param[in] config_descr Configuration descriptor.
    8687 * @param[in] config_descr_size Size of configuration descriptor.
    8788 * @param[in] interface_number Interface number.
     89 * @param[out] alternates_ptr Where to store pointer to allocated structure.
    8890 * @return Error code.
    8991 */
    … …  
    99101        alternates->current = 0;
    100102
    101         /* No interfaces. */
    102103        if (interface_number < 0) {
    103104                return EOK;
    … …  
    106107        alternates->alternative_count
    107108            = usb_interface_count_alternates(config_descr, config_descr_size,
    108                 interface_number);
     109            interface_number);
    109110
    110111        if (alternates->alternative_count == 0) {
    … …  
    127128        };
    128129
    129         usb_alternate_interface_descriptors_t *iterator
     130        usb_alternate_interface_descriptors_t *cur_alt_iface
    130131            = &alternates->alternatives[0];
    131132
    132         const usb_alternate_interface_descriptors_t *end
    133             = &alternates->alternatives[alternates->alternative_count];
    134 
    135         const void *iface_ptr =
    136             usb_dp_get_nested_descriptor(&dp_parser, &dp_data, dp_data.data);
    137 
    138         while (iface_ptr != NULL && iterator < end) {
    139                 const usb_standard_interface_descriptor_t *iface = iface_ptr;
    140 
     133        const uint8_t *iface_ptr = usb_dp_get_nested_descriptor(&dp_parser,
     134            &dp_data, dp_data.data);
     135        while (iface_ptr != NULL) {
     136                usb_standard_interface_descriptor_t *iface
     137                    = (usb_standard_interface_descriptor_t *) iface_ptr;
    141138                if ((iface->descriptor_type != USB_DESCTYPE_INTERFACE)
    142139                    || (iface->interface_number != interface_number)) {
    143                         /* This is not a valid alternate interface descriptor
    144                          * for interface with number == interface_number. */
    145140                        iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser,
    146141                            &dp_data, dp_data.data, iface_ptr);
    … …  
    148143                }
    149144
    150                 iterator->interface = iface;
    151                 iterator->nested_descriptors = iface_ptr + sizeof(*iface);
     145                cur_alt_iface->interface = iface;
     146                cur_alt_iface->nested_descriptors = iface_ptr + sizeof(*iface);
    152147
    153148                /* Find next interface to count size of nested descriptors. */
    154149                iface_ptr = usb_dp_get_sibling_descriptor(&dp_parser, &dp_data,
    155150                    dp_data.data, iface_ptr);
     151                if (iface_ptr == NULL) {
     152                        const uint8_t *next = dp_data.data + dp_data.size;
     153                        cur_alt_iface->nested_descriptors_size
     154                            = next - cur_alt_iface->nested_descriptors;
     155                } else {
     156                        cur_alt_iface->nested_descriptors_size
     157                            = iface_ptr - cur_alt_iface->nested_descriptors;
     158                }
    156159
    157                 const uint8_t *next = (iface_ptr == NULL) ?
    158                     dp_data.data + dp_data.size : iface_ptr;
    159 
    160                 iterator->nested_descriptors_size
    161                     = next - iterator->nested_descriptors;
    162 
    163                 ++iterator;
     160                cur_alt_iface++;
    164161        }
    165162

  • uspace/lib/usbdev/src/devpoll.c

    rb8b1e631 r07fd4cd1  
    4646/** Data needed for polling. */
    4747typedef struct {
    48         usb_device_auto_polling_t auto_polling;
     48        int debug;
     49        size_t max_failures;
     50        useconds_t delay;
     51        bool auto_clear_halt;
     52        bool (*on_data)(usb_device_t *, uint8_t *, size_t, void *);
     53        void (*on_polling_end)(usb_device_t *, bool, void *);
     54        bool (*on_error)(usb_device_t *, int, void *);
    4955
    5056        usb_device_t *dev;
    … …  
    6369static int polling_fibril(void *arg)
    6470{
    65         assert(arg);
    66         const polling_data_t *data = arg;
    67         /* Helper to reduce typing. */
    68         const usb_device_auto_polling_t *params = &data->auto_polling;
     71        polling_data_t *polling_data = (polling_data_t *) arg;
     72        assert(polling_data);
    6973
    7074        usb_pipe_t *pipe
    71             = &data->dev->pipes[data->pipe_index].pipe;
    72 
    73         if (params->debug > 0) {
    74                 const usb_endpoint_mapping_t *mapping
    75                     = &data->dev->pipes[data->pipe_index];
     75            = &polling_data->dev->pipes[polling_data->pipe_index].pipe;
     76       
     77        if (polling_data->debug > 0) {
     78                usb_endpoint_mapping_t *mapping
     79                    = &polling_data->dev->pipes[polling_data->pipe_index];
    7680                usb_log_debug("Poll%p: started polling of `%s' - " \
    7781                    "interface %d (%s,%d,%d), %zuB/%zu.\n",
    78                     data, data->dev->ddf_dev->name,
     82                    polling_data,
     83                    polling_data->dev->ddf_dev->name,
    7984                    (int) mapping->interface->interface_number,
    8085                    usb_str_class(mapping->interface->interface_class),
    8186                    (int) mapping->interface->interface_subclass,
    8287                    (int) mapping->interface->interface_protocol,
    83                     data->request_size, pipe->max_packet_size);
    84         }
    85 
    86         usb_pipe_start_long_transfer(pipe);
     88                    polling_data->request_size, pipe->max_packet_size);
     89        }
     90
    8791        size_t failed_attempts = 0;
    88         while (failed_attempts <= params->max_failures) {
     92        while (failed_attempts <= polling_data->max_failures) {
     93                int rc;
     94
    8995                size_t actual_size;
    90                 const int rc = usb_pipe_read(pipe, data->buffer,
    91                     data->request_size, &actual_size);
    92 
    93                 if (params->debug > 1) {
     96                rc = usb_pipe_read(pipe, polling_data->buffer,
     97                    polling_data->request_size, &actual_size);
     98
     99                if (polling_data->debug > 1) {
    94100                        if (rc == EOK) {
    95101                                usb_log_debug(
    96102                                    "Poll%p: received: '%s' (%zuB).\n",
    97                                     data,
    98                                     usb_debug_str_buffer(data->buffer,
     103                                    polling_data,
     104                                    usb_debug_str_buffer(polling_data->buffer,
    99105                                        actual_size, 16),
    100106                                    actual_size);
    … …  
    102108                                usb_log_debug(
    103109                                    "Poll%p: polling failed: %s.\n",
    104                                     data, str_error(rc));
     110                                    polling_data, str_error(rc));
    105111                        }
    106112                }
    107113
    108114                /* If the pipe stalled, we can try to reset the stall. */
    109                 if ((rc == ESTALL) && (params->auto_clear_halt)) {
     115                if ((rc == ESTALL) && (polling_data->auto_clear_halt)) {
    110116                        /*
    111117                         * We ignore error here as this is usually a futile
    … …  
    113119                         */
    114120                        usb_request_clear_endpoint_halt(
    115                             &data->dev->ctrl_pipe, pipe->endpoint_no);
     121                            &polling_data->dev->ctrl_pipe,
     122                            pipe->endpoint_no);
    116123                }
    117124
    118125                if (rc != EOK) {
    119                         ++failed_attempts;
    120                         const bool cont = (params->on_error == NULL) ? true :
    121                             params->on_error(data->dev, rc, data->custom_arg);
    122                         if (!cont) {
    123                                 failed_attempts = params->max_failures;
     126                        if (polling_data->on_error != NULL) {
     127                                bool cont = polling_data->on_error(
     128                                    polling_data->dev, rc,
     129                                    polling_data->custom_arg);
     130                                if (!cont) {
     131                                        failed_attempts
     132                                            = polling_data->max_failures;
     133                                }
    124134                        }
     135                        failed_attempts++;
    125136                        continue;
    126137                }
    127138
    128139                /* We have the data, execute the callback now. */
    129                 assert(params->on_data);
    130                 const bool carry_on = params->on_data(
    131                     data->dev, data->buffer, actual_size, data->custom_arg);
     140                bool carry_on = polling_data->on_data(polling_data->dev,
     141                    polling_data->buffer, actual_size,
     142                    polling_data->custom_arg);
    132143
    133144                if (!carry_on) {
    134                         /* This is user requested abort, erases failures. */
    135145                        failed_attempts = 0;
    136146                        break;
    … …  
    141151
    142152                /* Take a rest before next request. */
    143                 async_usleep(params->delay);
    144         }
    145 
    146         usb_pipe_end_long_transfer(pipe);
    147 
    148         const bool failed = failed_attempts > 0;
    149 
    150         if (params->on_polling_end != NULL) {
    151                 params->on_polling_end(data->dev, failed, data->custom_arg);
    152         }
    153 
    154         if (params->debug > 0) {
    155                 if (failed) {
    156                         usb_log_error("Polling of device `%s' terminated: "
    157                             "recurring failures.\n", data->dev->ddf_dev->name);
     153                async_usleep(polling_data->delay);
     154        }
     155
     156        if (polling_data->on_polling_end != NULL) {
     157                polling_data->on_polling_end(polling_data->dev,
     158                    failed_attempts > 0, polling_data->custom_arg);
     159        }
     160
     161        if (polling_data->debug > 0) {
     162                if (failed_attempts > 0) {
     163                        usb_log_error(
     164                            "Polling of device `%s' terminated: %s.\n",
     165                            polling_data->dev->ddf_dev->name,
     166                            "recurring failures");
    158167                } else {
    159                         usb_log_debug("Polling of device `%s' terminated: "
    160                             "driver request.\n", data->dev->ddf_dev->name);
     168                        usb_log_debug(
     169                            "Polling of device `%s' terminated by user.\n",
     170                            polling_data->dev->ddf_dev->name
     171                        );
    161172                }
    162173        }
    163174
    164175        /* Free the allocated memory. */
    165         free(data->buffer);
    166         free(data);
     176        free(polling_data->buffer);
     177        free(polling_data);
    167178
    168179        return EOK;
    … …  
    191202    usb_polling_terminted_callback_t terminated_callback, void *arg)
    192203{
     204        if ((dev == NULL) || (callback == NULL)) {
     205                return EBADMEM;
     206        }
     207        if (request_size == 0) {
     208                return EINVAL;
     209        }
     210        if ((dev->pipes[pipe_index].pipe.transfer_type != USB_TRANSFER_INTERRUPT)
     211            || (dev->pipes[pipe_index].pipe.direction != USB_DIRECTION_IN)) {
     212                return EINVAL;
     213        }
     214
    193215        const usb_device_auto_polling_t auto_polling = {
    194216                .debug = 1,
    … …  
    226248    size_t request_size, void *arg)
    227249{
    228         if ((dev == NULL) || (polling == NULL) || (polling->on_data == NULL)) {
     250        if (dev == NULL) {
    229251                return EBADMEM;
    230252        }
    231 
    232         if (pipe_index >= dev->pipes_count || request_size == 0) {
     253        if (pipe_index >= dev->pipes_count) {
    233254                return EINVAL;
    234255        }
    … …  
    236257            || (dev->pipes[pipe_index].pipe.direction != USB_DIRECTION_IN)) {
    237258                return EINVAL;
     259        }
     260        if ((polling == NULL) || (polling->on_data == NULL)) {
     261                return EBADMEM;
    238262        }
    239263
    … …  
    254278        polling_data->custom_arg = arg;
    255279
    256         /* Copy provided settings. */
    257         polling_data->auto_polling = *polling;
    258 
    259         /* Negative value means use descriptor provided value. */
    260         if (polling->delay < 0) {
    261                 polling_data->auto_polling.delay =
    262                     (int) dev->pipes[pipe_index].descriptor->poll_interval;
    263         }
     280        polling_data->debug = polling->debug;
     281        polling_data->max_failures = polling->max_failures;
     282        if (polling->delay >= 0) {
     283                polling_data->delay = (useconds_t) polling->delay;
     284        } else {
     285                polling_data->delay = (useconds_t) dev->pipes[pipe_index]
     286                    .descriptor->poll_interval;
     287        }
     288        polling_data->auto_clear_halt = polling->auto_clear_halt;
     289
     290        polling_data->on_data = polling->on_data;
     291        polling_data->on_polling_end = polling->on_polling_end;
     292        polling_data->on_error = polling->on_error;
    264293
    265294        fid_t fibril = fibril_create(polling_fibril, polling_data);

  • uspace/lib/usbdev/src/hub.c

    rb8b1e631 r07fd4cd1  
    7676{
    7777        CHECK_CONNECTION(connection);
    78 
     78       
    7979        async_exch_t *exch = async_exchange_begin(connection->hc_sess);
    80         if (!exch)
    81                 return (usb_address_t)ENOMEM;
    82 
    83         usb_address_t address = preferred;
    84         const int ret = usbhc_request_address(exch, &address, strict, speed);
    85 
     80       
     81        sysarg_t address;
     82        int rc = async_req_4_1(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
     83            IPC_M_USBHC_REQUEST_ADDRESS, preferred, strict, speed, &address);
     84       
    8685        async_exchange_end(exch);
    87         return ret == EOK ? address : ret;
     86       
     87        if (rc != EOK)
     88                return (usb_address_t) rc;
     89       
     90        return (usb_address_t) address;
    8891}
    8992
    … …  
    9497 * @return Error code.
    9598 */
    96 int usb_hc_register_device(usb_hc_connection_t *connection,
     99int usb_hc_register_device(usb_hc_connection_t * connection,
    97100    const usb_hub_attached_device_t *attached_device)
    98101{
    99102        CHECK_CONNECTION(connection);
    100         if (attached_device == NULL || attached_device->fun == NULL)
    101                 return EINVAL;
    102 
     103       
     104        if (attached_device == NULL)
     105                return EBADMEM;
     106       
    103107        async_exch_t *exch = async_exchange_begin(connection->hc_sess);
    104         if (!exch)
    105                 return ENOMEM;
    106         const int ret = usbhc_bind_address(exch,
     108        int rc = async_req_3_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
     109            IPC_M_USBHC_BIND_ADDRESS,
    107110            attached_device->address, attached_device->fun->handle);
    108111        async_exchange_end(exch);
    109 
    110         return ret;
     112       
     113        return rc;
    111114}
    112115
    … …  
    121124{
    122125        CHECK_CONNECTION(connection);
    123 
     126       
    124127        async_exch_t *exch = async_exchange_begin(connection->hc_sess);
    125         if (!exch)
    126                 return ENOMEM;
    127         const int ret = usbhc_release_address(exch, address);
     128        int rc = async_req_2_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
     129            IPC_M_USBHC_RELEASE_ADDRESS, address);
    128130        async_exchange_end(exch);
    129 
    130         return ret;
     131       
     132        return rc;
    131133}
    132134
    … …  
    219221 *      request or requests for descriptors when creating match ids).
    220222 */
    221 int usb_hc_new_device_wrapper(ddf_dev_t *parent,
    222     usb_hc_connection_t *connection, usb_speed_t dev_speed,
     223int usb_hc_new_device_wrapper(ddf_dev_t *parent, usb_hc_connection_t *connection,
     224    usb_speed_t dev_speed,
    223225    int (*enable_port)(void *arg), void *arg, usb_address_t *assigned_address,
    224226    ddf_dev_ops_t *dev_ops, void *new_dev_data, ddf_fun_t **new_fun)
    … …  
    227229                return EINVAL;
    228230
     231        // FIXME: this is awful, we are accessing directly the structure.
    229232        // TODO: Why not use provided connection?
    230         usb_hc_connection_t hc_conn;
    231         usb_hc_connection_initialize(&hc_conn, connection->hc_handle);
     233        usb_hc_connection_t hc_conn = {
     234                .hc_handle = connection->hc_handle,
     235                .hc_sess = NULL
     236        };
    232237
    233238        int rc;

  • uspace/lib/usbdev/src/pipepriv.c

    rb8b1e631 r07fd4cd1  
    8787       
    8888        if (pipe->refcount == 0) {
    89                 assert(pipe->hc_sess == NULL);
    9089                /* Need to open the phone by ourselves. */
    9190                async_sess_t *sess =

  • uspace/lib/usbdev/src/pipes.c

    rb8b1e631 r07fd4cd1  
    5454static usb_address_t get_my_address(async_sess_t *sess, const ddf_dev_t *dev)
    5555{
    56         assert(sess);
    5756        async_exch_t *exch = async_exchange_begin(sess);
    58         if (!exch)
    59                 return ENOMEM;
    60 
    61         usb_address_t address;
    62         const int ret = usb_get_my_address(exch, &address);
    63 
     57       
     58        sysarg_t address;
     59        int rc = async_req_1_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
     60            IPC_M_USB_GET_MY_ADDRESS, &address);
     61       
    6462        async_exchange_end(exch);
    65 
    66         return (ret == EOK) ? address : ret;
     63       
     64        if (rc != EOK)
     65                return rc;
     66       
     67        return (usb_address_t) address;
    6768}
    6869
    … …  
    7071 *
    7172 * @param device Device in question.
    72  * @return Error code (ENOTSUP means any).
     73 * @return Interface number (negative code means any).
    7374 */
    7475int usb_device_get_assigned_interface(const ddf_dev_t *device)
    … …  
    7980            IPC_FLAG_BLOCKING);
    8081        if (!parent_sess)
    81                 return ENOMEM;
    82 
     82                return -1;
     83       
    8384        async_exch_t *exch = async_exchange_begin(parent_sess);
    84         if (!exch) {
    85                 async_hangup(parent_sess);
    86                 return ENOMEM;
    87         }
    88 
    89         int iface_no;
    90         const int ret = usb_get_my_interface(exch, &iface_no);
    91 
    92         return ret == EOK ? iface_no : ret;
     85       
     86        sysarg_t iface_no;
     87        int rc = async_req_2_1(exch, DEV_IFACE_ID(USB_DEV_IFACE),
     88            IPC_M_USB_GET_INTERFACE, device->handle, &iface_no);
     89       
     90        async_exchange_end(exch);
     91        async_hangup(parent_sess);
     92       
     93        if (rc != EOK)
     94                return -1;
     95       
     96        return (int) iface_no;
    9397}
    9498

  • uspace/lib/usbdev/src/pipesinit.c

    rb8b1e631 r07fd4cd1  
    5454
    5555/** Nesting pairs of standard descriptors. */
    56 static const usb_dp_descriptor_nesting_t descriptor_nesting[] = {
     56static usb_dp_descriptor_nesting_t descriptor_nesting[] = {
    5757        NESTING(CONFIGURATION, INTERFACE),
    5858        NESTING(INTERFACE, ENDPOINT),
    … …  
    405405        }
    406406
     407#define TRY_LOOP(attempt_var) \
     408        for (attempt_var = 0; attempt_var < 3; attempt_var++)
     409
     410        size_t failed_attempts;
     411        int rc;
    407412
    408413        usb_pipe_start_long_transfer(pipe);
    … …  
    410415        uint8_t dev_descr_start[CTRL_PIPE_MIN_PACKET_SIZE];
    411416        size_t transferred_size;
    412         int rc;
    413         for (size_t attempt_var = 0; attempt_var < 3; ++attempt_var) {
     417        TRY_LOOP(failed_attempts) {
    414418                rc = usb_request_get_descriptor(pipe, USB_REQUEST_TYPE_STANDARD,
    415419                    USB_REQUEST_RECIPIENT_DEVICE, USB_DESCTYPE_DEVICE,
    … …  
    446450{
    447451        assert(pipe);
    448         assert(pipe->wire);
    449452        assert(hc_connection);
    450453
    451454        if (!usb_hc_connection_is_opened(hc_connection))
    452455                return EBADF;
     456
     457        const usb_target_t target =
     458            {{ .address = pipe->wire->address, .endpoint = pipe->endpoint_no }};
     459#define _PACK2(high, low) (((high & 0xffff) << 16) | (low & 0xffff))
     460
    453461        async_exch_t *exch = async_exchange_begin(hc_connection->hc_sess);
    454         if (!exch)
    455                 return ENOMEM;
    456         const int ret = usbhc_register_endpoint(exch,
    457             pipe->wire->address, pipe->endpoint_no, pipe->transfer_type,
    458             pipe->direction, pipe->max_packet_size, interval);
    459 
     462        int rc = async_req_4_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
     463            IPC_M_USBHC_REGISTER_ENDPOINT, target.packed,
     464            _PACK2(pipe->transfer_type, pipe->direction),
     465            _PACK2(pipe->max_packet_size, interval));
    460466        async_exchange_end(exch);
    461         return ret;
     467
     468#undef _PACK2
     469        return rc;
    462470}
    463471
    … …  
    474482        assert(pipe->wire);
    475483        assert(hc_connection);
    476 
     484       
    477485        if (!usb_hc_connection_is_opened(hc_connection))
    478486                return EBADF;
    479 
     487       
    480488        async_exch_t *exch = async_exchange_begin(hc_connection->hc_sess);
    481         if (!exch)
    482                 return ENOMEM;
    483         const int ret = usbhc_unregister_endpoint(exch,
     489        int rc = async_req_4_0(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
     490            IPC_M_USBHC_UNREGISTER_ENDPOINT,
    484491            pipe->wire->address, pipe->endpoint_no, pipe->direction);
    485492        async_exchange_end(exch);
    486 
    487         return ret;
     493       
     494        return rc;
    488495}
    489496

  • uspace/lib/usbdev/src/pipesio.c

    rb8b1e631 r07fd4cd1  
    6262 * @return Error code.
    6363 */
    64 static int usb_pipe_read_no_check(usb_pipe_t *pipe, uint64_t setup,
     64static int usb_pipe_read_no_checks(usb_pipe_t *pipe,
    6565    void *buffer, size_t size, size_t *size_transfered)
    6666{
    67         /* Isochronous transfer are not supported (yet) */
     67        /* Only interrupt and bulk transfers are supported */
    6868        if (pipe->transfer_type != USB_TRANSFER_INTERRUPT &&
    69             pipe->transfer_type != USB_TRANSFER_BULK &&
    70             pipe->transfer_type != USB_TRANSFER_CONTROL)
     69            pipe->transfer_type != USB_TRANSFER_BULK)
    7170            return ENOTSUP;
    7271
    73         int ret = pipe_add_ref(pipe, false);
    74         if (ret != EOK) {
    75                 return ret;
    76         }
    77 
     72        const usb_target_t target =
     73            {{ .address = pipe->wire->address, .endpoint = pipe->endpoint_no }};
     74       
    7875        /* Ensure serialization over the phone. */
    7976        pipe_start_transaction(pipe);
    8077        async_exch_t *exch = async_exchange_begin(pipe->hc_sess);
    81         if (!exch) {
     78       
     79        /*
     80         * Make call identifying target USB device and type of transfer.
     81         */
     82        aid_t opening_request = async_send_2(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
     83            IPC_M_USBHC_READ, target.packed, NULL);
     84       
     85        if (opening_request == 0) {
     86                async_exchange_end(exch);
    8287                pipe_end_transaction(pipe);
    83                 pipe_drop_ref(pipe);
    8488                return ENOMEM;
    8589        }
    86 
    87         ret = usbhc_read(exch, pipe->wire->address, pipe->endpoint_no,
    88             setup, buffer, size, size_transfered);
     90       
     91        /*
     92         * Retrieve the data.
     93         */
     94        ipc_call_t data_request_call;
     95        aid_t data_request = async_data_read(exch, buffer, size,
     96            &data_request_call);
     97       
     98        /*
     99         * Since now on, someone else might access the backing phone
     100         * without breaking the transfer IPC protocol.
     101         */
    89102        async_exchange_end(exch);
    90103        pipe_end_transaction(pipe);
     104       
     105        if (data_request == 0) {
     106                /*
     107                 * FIXME:
     108                 * How to let the other side know that we want to abort?
     109                 */
     110                async_wait_for(opening_request, NULL);
     111                return ENOMEM;
     112        }
     113       
     114        /*
     115         * Wait for the answer.
     116         */
     117        sysarg_t data_request_rc;
     118        sysarg_t opening_request_rc;
     119        async_wait_for(data_request, &data_request_rc);
     120        async_wait_for(opening_request, &opening_request_rc);
     121       
     122        if (data_request_rc != EOK) {
     123                /* Prefer the return code of the opening request. */
     124                if (opening_request_rc != EOK) {
     125                        return (int) opening_request_rc;
     126                } else {
     127                        return (int) data_request_rc;
     128                }
     129        }
     130        if (opening_request_rc != EOK) {
     131                return (int) opening_request_rc;
     132        }
     133       
     134        *size_transfered = IPC_GET_ARG2(data_request_call);
     135       
     136        return EOK;
     137}
     138
     139
     140/** Request a read (in) transfer on an endpoint pipe.
     141 *
     142 * @param[in] pipe Pipe used for the transfer.
     143 * @param[out] buffer Buffer where to store the data.
     144 * @param[in] size Size of the buffer (in bytes).
     145 * @param[out] size_transfered Number of bytes that were actually transfered.
     146 * @return Error code.
     147 */
     148int usb_pipe_read(usb_pipe_t *pipe,
     149    void *buffer, size_t size, size_t *size_transfered)
     150{
     151        assert(pipe);
     152
     153        if (buffer == NULL) {
     154                return EINVAL;
     155        }
     156
     157        if (size == 0) {
     158                return EINVAL;
     159        }
     160
     161        if (pipe->direction != USB_DIRECTION_IN) {
     162                return EBADF;
     163        }
     164
     165        if (pipe->transfer_type == USB_TRANSFER_CONTROL) {
     166                return EBADF;
     167        }
     168
     169        int rc;
     170        rc = pipe_add_ref(pipe, false);
     171        if (rc != EOK) {
     172                return rc;
     173        }
     174
     175
     176        size_t act_size = 0;
     177
     178        rc = usb_pipe_read_no_checks(pipe, buffer, size, &act_size);
     179
    91180        pipe_drop_ref(pipe);
    92         return ret;
    93 }
     181
     182        if (rc != EOK) {
     183                return rc;
     184        }
     185
     186        if (size_transfered != NULL) {
     187                *size_transfered = act_size;
     188        }
     189
     190        return EOK;
     191}
     192
     193
     194
    94195
    95196/** Request an out transfer, no checking of input parameters.
    … …  
    100201 * @return Error code.
    101202 */
    102 static int usb_pipe_write_no_check(usb_pipe_t *pipe, uint64_t setup,
    103     const void *buffer, size_t size)
     203static int usb_pipe_write_no_check(usb_pipe_t *pipe,
     204    void *buffer, size_t size)
    104205{
    105206        /* Only interrupt and bulk transfers are supported */
    106207        if (pipe->transfer_type != USB_TRANSFER_INTERRUPT &&
    107             pipe->transfer_type != USB_TRANSFER_BULK &&
    108             pipe->transfer_type != USB_TRANSFER_CONTROL)
     208            pipe->transfer_type != USB_TRANSFER_BULK)
    109209            return ENOTSUP;
    110210
    111         int ret = pipe_add_ref(pipe, false);
    112         if (ret != EOK) {
    113                 return ret;
    114         }
     211        const usb_target_t target =
     212            {{ .address = pipe->wire->address, .endpoint = pipe->endpoint_no }};
    115213
    116214        /* Ensure serialization over the phone. */
    117215        pipe_start_transaction(pipe);
    118216        async_exch_t *exch = async_exchange_begin(pipe->hc_sess);
    119         if (!exch) {
     217       
     218        /*
     219         * Make call identifying target USB device and type of transfer.
     220         */
     221        aid_t opening_request = async_send_3(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
     222            IPC_M_USBHC_WRITE, target.packed, size, NULL);
     223       
     224        if (opening_request == 0) {
     225                async_exchange_end(exch);
    120226                pipe_end_transaction(pipe);
    121                 pipe_drop_ref(pipe);
    122227                return ENOMEM;
    123228        }
    124         ret = usbhc_write(exch, pipe->wire->address, pipe->endpoint_no,
    125             setup, buffer, size);
     229       
     230        /*
     231         * Send the data.
     232         */
     233        int rc = async_data_write_start(exch, buffer, size);
     234       
     235        /*
     236         * Since now on, someone else might access the backing phone
     237         * without breaking the transfer IPC protocol.
     238         */
    126239        async_exchange_end(exch);
    127240        pipe_end_transaction(pipe);
     241       
     242        if (rc != EOK) {
     243                async_wait_for(opening_request, NULL);
     244                return rc;
     245        }
     246       
     247        /*
     248         * Wait for the answer.
     249         */
     250        sysarg_t opening_request_rc;
     251        async_wait_for(opening_request, &opening_request_rc);
     252       
     253        return (int) opening_request_rc;
     254}
     255
     256/** Request a write (out) transfer on an endpoint pipe.
     257 *
     258 * @param[in] pipe Pipe used for the transfer.
     259 * @param[in] buffer Buffer with data to transfer.
     260 * @param[in] size Size of the buffer (in bytes).
     261 * @return Error code.
     262 */
     263int usb_pipe_write(usb_pipe_t *pipe,
     264    void *buffer, size_t size)
     265{
     266        assert(pipe);
     267
     268        if (buffer == NULL) {
     269                return EINVAL;
     270        }
     271
     272        if (size == 0) {
     273                return EINVAL;
     274        }
     275
     276        if (pipe->direction != USB_DIRECTION_OUT) {
     277                return EBADF;
     278        }
     279
     280        if (pipe->transfer_type == USB_TRANSFER_CONTROL) {
     281                return EBADF;
     282        }
     283
     284        int rc;
     285
     286        rc = pipe_add_ref(pipe, false);
     287        if (rc != EOK) {
     288                return rc;
     289        }
     290
     291        rc = usb_pipe_write_no_check(pipe, buffer, size);
     292
    128293        pipe_drop_ref(pipe);
    129         return ret;
     294
     295        return rc;
    130296}
    131297
    … …  
    143309
    144310
    145         /* Prevent infinite recursion. */
     311        /* Prevent indefinite recursion. */
    146312        pipe->auto_reset_halt = false;
    147313        usb_request_clear_endpoint_halt(pipe, 0);
    … …  
    149315}
    150316
    151 /** Request a control read transfer on an endpoint pipe.
    152  *
    153  * This function encapsulates all three stages of a control transfer.
     317
     318/** Request a control read transfer, no checking of input parameters.
    154319 *
    155320 * @param[in] pipe Pipe used for the transfer.
    … …  
    162327 * @return Error code.
    163328 */
     329static int usb_pipe_control_read_no_check(usb_pipe_t *pipe,
     330    const void *setup_buffer, size_t setup_buffer_size,
     331    void *data_buffer, size_t data_buffer_size, size_t *data_transfered_size)
     332{
     333        /* Ensure serialization over the phone. */
     334        pipe_start_transaction(pipe);
     335
     336        const usb_target_t target =
     337            {{ .address = pipe->wire->address, .endpoint = pipe->endpoint_no }};
     338
     339        assert(setup_buffer_size == 8);
     340        uint64_t setup_packet;
     341        memcpy(&setup_packet, setup_buffer, 8);
     342        /*
     343         * Make call identifying target USB device and control transfer type.
     344         */
     345        async_exch_t *exch = async_exchange_begin(pipe->hc_sess);
     346        aid_t opening_request = async_send_4(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
     347            IPC_M_USBHC_READ, target.packed,
     348            (setup_packet & UINT32_MAX), (setup_packet >> 32), NULL);
     349
     350        if (opening_request == 0) {
     351                async_exchange_end(exch);
     352                return ENOMEM;
     353        }
     354
     355        /*
     356         * Retrieve the data.
     357         */
     358        ipc_call_t data_request_call;
     359        aid_t data_request = async_data_read(exch, data_buffer,
     360            data_buffer_size, &data_request_call);
     361       
     362        /*
     363         * Since now on, someone else might access the backing phone
     364         * without breaking the transfer IPC protocol.
     365         */
     366        async_exchange_end(exch);
     367        pipe_end_transaction(pipe);
     368       
     369        if (data_request == 0) {
     370                async_wait_for(opening_request, NULL);
     371                return ENOMEM;
     372        }
     373
     374        /*
     375         * Wait for the answer.
     376         */
     377        sysarg_t data_request_rc;
     378        sysarg_t opening_request_rc;
     379        async_wait_for(data_request, &data_request_rc);
     380        async_wait_for(opening_request, &opening_request_rc);
     381
     382        if (data_request_rc != EOK) {
     383                /* Prefer the return code of the opening request. */
     384                if (opening_request_rc != EOK) {
     385                        return (int) opening_request_rc;
     386                } else {
     387                        return (int) data_request_rc;
     388                }
     389        }
     390        if (opening_request_rc != EOK) {
     391                return (int) opening_request_rc;
     392        }
     393
     394        *data_transfered_size = IPC_GET_ARG2(data_request_call);
     395
     396        return EOK;
     397}
     398
     399/** Request a control read transfer on an endpoint pipe.
     400 *
     401 * This function encapsulates all three stages of a control transfer.
     402 *
     403 * @param[in] pipe Pipe used for the transfer.
     404 * @param[in] setup_buffer Buffer with the setup packet.
     405 * @param[in] setup_buffer_size Size of the setup packet (in bytes).
     406 * @param[out] data_buffer Buffer for incoming data.
     407 * @param[in] data_buffer_size Size of the buffer for incoming data (in bytes).
     408 * @param[out] data_transfered_size Number of bytes that were actually
     409 *                                  transfered during the DATA stage.
     410 * @return Error code.
     411 */
    164412int usb_pipe_control_read(usb_pipe_t *pipe,
    165413    const void *setup_buffer, size_t setup_buffer_size,
    … …  
    168416        assert(pipe);
    169417
    170         if ((setup_buffer == NULL) || (setup_buffer_size != 8)) {
     418        if ((setup_buffer == NULL) || (setup_buffer_size == 0)) {
    171419                return EINVAL;
    172420        }
    … …  
    181429        }
    182430
    183         uint64_t setup_packet;
    184         memcpy(&setup_packet, setup_buffer, 8);
     431        int rc;
     432
     433        rc = pipe_add_ref(pipe, false);
     434        if (rc != EOK) {
     435                return rc;
     436        }
    185437
    186438        size_t act_size = 0;
    187         const int rc = usb_pipe_read_no_check(pipe, setup_packet,
     439        rc = usb_pipe_control_read_no_check(pipe,
     440            setup_buffer, setup_buffer_size,
    188441            data_buffer, data_buffer_size, &act_size);
    189442
    … …  
    192445        }
    193446
    194         if (rc == EOK && data_transfered_size != NULL) {
     447        pipe_drop_ref(pipe);
     448
     449        if (rc != EOK) {
     450                return rc;
     451        }
     452
     453        if (data_transfered_size != NULL) {
    195454                *data_transfered_size = act_size;
    196455        }
    197456
    198         return rc;
    199 }
    200 
    201 /** Request a control write transfer on an endpoint pipe.
    202  *
    203  * This function encapsulates all three stages of a control transfer.
     457        return EOK;
     458}
     459
     460
     461/** Request a control write transfer, no checking of input parameters.
    204462 *
    205463 * @param[in] pipe Pipe used for the transfer.
    … …  
    210468 * @return Error code.
    211469 */
     470static int usb_pipe_control_write_no_check(usb_pipe_t *pipe,
     471    const void *setup_buffer, size_t setup_buffer_size,
     472    const void *data_buffer, size_t data_buffer_size)
     473{
     474        /* Ensure serialization over the phone. */
     475        pipe_start_transaction(pipe);
     476
     477        const usb_target_t target =
     478            {{ .address = pipe->wire->address, .endpoint = pipe->endpoint_no }};
     479        assert(setup_buffer_size == 8);
     480        uint64_t setup_packet;
     481        memcpy(&setup_packet, setup_buffer, 8);
     482
     483        /*
     484         * Make call identifying target USB device and control transfer type.
     485         */
     486        async_exch_t *exch = async_exchange_begin(pipe->hc_sess);
     487        aid_t opening_request = async_send_5(exch, DEV_IFACE_ID(USBHC_DEV_IFACE),
     488            IPC_M_USBHC_WRITE, target.packed, data_buffer_size,
     489            (setup_packet & UINT32_MAX), (setup_packet >> 32), NULL);
     490       
     491        if (opening_request == 0) {
     492                async_exchange_end(exch);
     493                pipe_end_transaction(pipe);
     494                return ENOMEM;
     495        }
     496
     497        /*
     498         * Send the data (if any).
     499         */
     500        if (data_buffer_size > 0) {
     501                int rc = async_data_write_start(exch, data_buffer, data_buffer_size);
     502               
     503                /* All data sent, pipe can be released. */
     504                async_exchange_end(exch);
     505                pipe_end_transaction(pipe);
     506       
     507                if (rc != EOK) {
     508                        async_wait_for(opening_request, NULL);
     509                        return rc;
     510                }
     511        } else {
     512                /* No data to send, we can release the pipe for others. */
     513                async_exchange_end(exch);
     514                pipe_end_transaction(pipe);
     515        }
     516       
     517        /*
     518         * Wait for the answer.
     519         */
     520        sysarg_t opening_request_rc;
     521        async_wait_for(opening_request, &opening_request_rc);
     522
     523        return (int) opening_request_rc;
     524}
     525
     526/** Request a control write transfer on an endpoint pipe.
     527 *
     528 * This function encapsulates all three stages of a control transfer.
     529 *
     530 * @param[in] pipe Pipe used for the transfer.
     531 * @param[in] setup_buffer Buffer with the setup packet.
     532 * @param[in] setup_buffer_size Size of the setup packet (in bytes).
     533 * @param[in] data_buffer Buffer with data to be sent.
     534 * @param[in] data_buffer_size Size of the buffer with outgoing data (in bytes).
     535 * @return Error code.
     536 */
    212537int usb_pipe_control_write(usb_pipe_t *pipe,
    213538    const void *setup_buffer, size_t setup_buffer_size,
    … …  
    216541        assert(pipe);
    217542
    218         if ((setup_buffer == NULL) || (setup_buffer_size != 8)) {
     543        if ((setup_buffer == NULL) || (setup_buffer_size == 0)) {
    219544                return EINVAL;
    220545        }
    … …  
    233558        }
    234559
    235         uint64_t setup_packet;
    236         memcpy(&setup_packet, setup_buffer, 8);
    237 
    238         const int rc = usb_pipe_write_no_check(pipe, setup_packet,
    239             data_buffer, data_buffer_size);
     560        int rc;
     561
     562        rc = pipe_add_ref(pipe, false);
     563        if (rc != EOK) {
     564                return rc;
     565        }
     566
     567        rc = usb_pipe_control_write_no_check(pipe,
     568            setup_buffer, setup_buffer_size, data_buffer, data_buffer_size);
    240569
    241570        if (rc == ESTALL) {
    … …  
    243572        }
    244573
     574        pipe_drop_ref(pipe);
     575
    245576        return rc;
    246577}
    247578
    248 /** Request a read (in) transfer on an endpoint pipe.
    249  *
    250  * @param[in] pipe Pipe used for the transfer.
    251  * @param[out] buffer Buffer where to store the data.
    252  * @param[in] size Size of the buffer (in bytes).
    253  * @param[out] size_transfered Number of bytes that were actually transfered.
    254  * @return Error code.
    255  */
    256 int usb_pipe_read(usb_pipe_t *pipe,
    257     void *buffer, size_t size, size_t *size_transfered)
    258 {
    259         assert(pipe);
    260 
    261         if (buffer == NULL) {
    262                 return EINVAL;
    263         }
    264 
    265         if (size == 0) {
    266                 return EINVAL;
    267         }
    268 
    269         if (pipe->direction != USB_DIRECTION_IN) {
    270                 return EBADF;
    271         }
    272 
    273         if (pipe->transfer_type == USB_TRANSFER_CONTROL) {
    274                 return EBADF;
    275         }
    276 
    277         size_t act_size = 0;
    278         const int rc = usb_pipe_read_no_check(pipe, 0, buffer, size, &act_size);
    279 
    280 
    281         if (rc == EOK && size_transfered != NULL) {
    282                 *size_transfered = act_size;
    283         }
    284 
    285         return rc;
    286 }
    287 
    288 /** Request a write (out) transfer on an endpoint pipe.
    289  *
    290  * @param[in] pipe Pipe used for the transfer.
    291  * @param[in] buffer Buffer with data to transfer.
    292  * @param[in] size Size of the buffer (in bytes).
    293  * @return Error code.
    294  */
    295 int usb_pipe_write(usb_pipe_t *pipe, const void *buffer, size_t size)
    296 {
    297         assert(pipe);
    298 
    299         if (buffer == NULL || size == 0) {
    300                 return EINVAL;
    301         }
    302 
    303         if (pipe->direction != USB_DIRECTION_OUT) {
    304                 return EBADF;
    305         }
    306 
    307         if (pipe->transfer_type == USB_TRANSFER_CONTROL) {
    308                 return EBADF;
    309         }
    310 
    311         return usb_pipe_write_no_check(pipe, 0, buffer, size);
    312 }
    313579
    314580/**

  • uspace/lib/usbdev/src/request.c

    rb8b1e631 r07fd4cd1  
    143143         */
    144144
    145         const usb_device_request_setup_packet_t setup_packet = {
    146                 .request_type = SETUP_REQUEST_TYPE_DEVICE_TO_HOST
    147                     | (request_type << 5) | recipient,
    148                 .request = request,
    149                 .value = value,
    150                 .index = index,
    151                 .length = (uint16_t) data_size,
    152         };
    153 
    154         return usb_pipe_control_read(pipe, &setup_packet, sizeof(setup_packet),
     145        usb_device_request_setup_packet_t setup_packet;
     146        setup_packet.request_type = 128 | (request_type << 5) | recipient;
     147        setup_packet.request = request;
     148        setup_packet.value = value;
     149        setup_packet.index = index;
     150        setup_packet.length = (uint16_t) data_size;
     151
     152        int rc = usb_pipe_control_read(pipe,
     153            &setup_packet, sizeof(setup_packet),
    155154            data, data_size, actual_data_size);
     155
     156        return rc;
    156157}
    157158
    … …  
    275276        }
    276277
    277         const uint16_t wValue = descriptor_index | (descriptor_type << 8);
     278        uint16_t wValue = descriptor_index | (descriptor_type << 8);
    278279
    279280        return usb_control_request_get(pipe,

  • uspace/lib/usbhost/include/usb/host/hcd.h

    rb8b1e631 r07fd4cd1  
    6363/*----------------------------------------------------------------------------*/
    6464/** Initialize hcd_t structure.
    65  * Initializes device and endpoint managers. Sets data and hook pointer to NULL.
     65 * Initializes device and endpoint managers. Sets data nd hook pointer to NULL.
    6666 * @param hcd hcd_t structure to initialize, non-null.
    6767 * @param bandwidth Available bandwidth, passed to endpoint manager.

  • uspace/lib/usbhost/src/iface.c

    rb8b1e631 r07fd4cd1  
    252252        .request_address = request_address,
    253253        .bind_address = bind_address,
    254         .get_handle = find_by_address,
     254        .find_by_address = find_by_address,
    255255        .release_address = release_address,
    256256
Note: See TracChangeset for help on using the changeset viewer.