Changeset 58563585 in mainline for uspace/lib


Ignore:
Timestamp:
2016-08-31T11:15:39Z (9 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
10cb47e
Parents:
7a67416
Message:

code review and cstyle cleanup (no change in functionality)

Location:
uspace/lib
Files:
42 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/arch/amd64/src/stacktrace_asm.S

    r7a67416 r58563585  
    4444        ret
    4545FUNCTION_END(stacktrace_pc_get)
    46 

  • uspace/lib/c/arch/arm32/src/eabi.S

    r7a67416 r58563585  
    9595        mov pc, lr
    9696FUNCTION_END(__aeabi_uldivmod)
    97 

  • uspace/lib/c/arch/arm32/src/stacktrace_asm.S

    r7a67416 r58563585  
    4444        mov pc, lr
    4545FUNCTION_END(stacktrace_pc_get)
    46 

  • uspace/lib/c/arch/ia32/src/rtld/reloc.c

    r7a67416 r58563585  
    6969        uint32_t sym_size;
    7070        char *str_tab;
    71 
     71       
    7272        elf_symbol_t *sym_def;
    7373        module_t *dest;
    … …  
    8080
    8181        DPRINTF("address: 0x%x, entries: %d\n", (uintptr_t)rt, rt_entries);
    82 
     82       
    8383        for (i = 0; i < rt_entries; ++i) {
    8484//              DPRINTF("symbol %d: ", i);
    … …  
    171171                        memcpy(r_ptr, (const void *)sym_addr, sym_size);
    172172                        break;
    173 
     173                       
    174174                case R_386_RELATIVE:
    175175                        DPRINTF("fixup R_386_RELATIVE (b+a)\n");

  • uspace/lib/c/arch/ia32/src/syscall.S

    r7a67416 r58563585  
    6363FUNCTION_END(__syscall_slow)
    6464
    65 
    6665/** Syscall wrapper - SYSENTER version.
    6766 *

  • uspace/lib/c/arch/ia64/src/fibril.S

    r7a67416 r58563585  
    338338        br.ret.sptk.many b0
    339339FUNCTION_END(context_restore)
    340 

  • uspace/lib/c/arch/ia64/src/stacktrace_asm.S

    r7a67416 r58563585  
    4141FUNCTION_END(stacktrace_fp_get)
    4242FUNCTION_END(stacktrace_pc_get)
    43 

  • uspace/lib/c/arch/ia64/src/syscall.S

    r7a67416 r58563585  
    4545        br.ret.sptk.many b0
    4646FUNCTION_END(__syscall)
    47 

  • uspace/lib/c/arch/mips32/src/entryjmp.S

    r7a67416 r58563585  
    5151        addiu $sp, ABI_STACK_FRAME
    5252FUNCTION_END(entry_point_jmp)
    53 

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

    r7a67416 r58563585  
    991991 * @param callid Hash of the incoming call.
    992992 * @param call   Data of the incoming call.
     993 *
    993994 */
    994995static void process_notification(ipc_callid_t callid, ipc_call_t *call)
    … …  
    13161317                fibril_t *fibril = (fibril_t *) __tcb_get()->fibril_data;
    13171318                unsigned oldsw = fibril->switches;
    1318 
     1319               
    13191320                process_notification(callid, call);
    1320 
     1321               
    13211322                if (oldsw != fibril->switches) {
    13221323                        /*
    … …  
    13341335                        fibril_switch(FIBRIL_FROM_DEAD);
    13351336                }
     1337               
    13361338                return;
    13371339        }

  • uspace/lib/c/generic/dnsr.c

    r7a67416 r58563585  
    124124                return (int) retval;
    125125        }
    126 
     126       
    127127        size_t act_size = IPC_GET_ARG2(answer_cname);
    128128        assert(act_size <= DNSR_NAME_MAX_SIZE);
    129129       
    130130        cname_buf[act_size] = '\0';
    131 
     131       
    132132        info->cname = str_dup(cname_buf);
    133 
     133       
    134134        if (info->cname == NULL) {
    135135                free(info);

  • uspace/lib/c/generic/rtld/module.c

    r7a67416 r58563585  
    151151                }
    152152        }
    153 
     153       
    154154        return NULL; /* Not found */
    155155}
    … …  
    167167        module_t *m;
    168168        int rc;
    169 
     169       
    170170        m = calloc(1, sizeof(module_t));
    171171        if (m == NULL) {
    … …  
    173173                exit(1);
    174174        }
    175 
     175       
    176176        m->rtld = rtld;
    177177        m->id = rtld_get_next_id(rtld);
    … …  
    217217        /* Insert into the list of loaded modules */
    218218        list_append(&m->modules_link, &rtld->modules);
    219 
     219       
    220220        /* Copy TLS info */
    221221        m->tdata = info.tls.tdata;
    … …  
    223223        m->tbss_size = info.tls.tbss_size;
    224224        m->tls_align = info.tls.tls_align;
    225 
     225       
    226226        DPRINTF("tdata at %p size %zu, tbss size %zu\n",
    227227            m->tdata, m->tdata_size, m->tbss_size);

  • uspace/lib/c/generic/tls.c

    r7a67416 r58563585  
    7474        tcb_t *tcb;
    7575        size_t tls_size = &_tbss_end - &_tdata_start;
    76 
     76       
    7777#ifdef CONFIG_RTLD
    7878        if (runtime_env != NULL)
    7979                return rtld_tls_make(runtime_env);
    8080#endif
     81       
    8182        tcb = tls_alloc_arch(&data, tls_size);
    8283        if (!tcb)
    8384                return NULL;
    84 
     85       
    8586        /*
    8687         * Copy thread local data from the initialization image.
    … …  
    118119        if (!tcb)
    119120                return NULL;
    120         *data = ((void *)tcb) + sizeof(tcb_t);
     121       
     122        *data = ((void *) tcb) + sizeof(tcb_t);
    121123#ifdef CONFIG_RTLD
    122124        tcb->dtv = NULL;
    … …  
    148150{
    149151        tcb_t *tcb;
    150 
     152       
    151153        size = ALIGN_UP(size, &_tls_alignment);
    152154        *data = memalign((uintptr_t) &_tls_alignment, sizeof(tcb_t) + size);

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

    r7a67416 r58563585  
    7979        fibril_owner_info_t *waits_for;
    8080
    81         unsigned switches;
     81        unsigned int switches;
    8282} fibril_t;
    8383

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

    r7a67416 r58563585  
    126126                return;
    127127        }
    128 
     128       
    129129        ddf_dev_t *dev = create_device();
    130130        if (!dev) {
    … …  
    133133                return;
    134134        }
    135 
     135       
    136136        /* Add one reference that will be dropped by driver_dev_remove() */
    137137        dev_add_ref(dev);

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

    r7a67416 r58563585  
    226226                return;
    227227        }       
    228 
     228       
    229229        const int ret = ahci_iface->get_sata_device_name(fun,
    230230            sata_dev_name_length, sata_dev_name);
    … …  
    235235            (real_size == sata_dev_name_length))
    236236                async_data_read_finalize(cid, sata_dev_name, sata_dev_name_length);
    237 
     237       
    238238        free(sata_dev_name);
    239239        async_answer_0(callid, ret);

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

    r7a67416 r58563585  
    9191
    9292/** Tell devman handle of the usb device function.
    93  * @param[in] exch IPC communication exchange
     93 *
     94 * @param[in]  exch   IPC communication exchange
    9495 * @param[out] handle devman handle of the HC used by the target device.
     96 *
    9597 * @return Error code.
     98 *
    9699 */
    97100int usb_get_my_device_handle(async_exch_t *exch, devman_handle_t *handle)
    … …  
    119122
    120123/** Release default USB address.
     124 *
    121125 * @param[in] exch IPC communication exchange
     126 *
    122127 * @return Error code.
     128 *
    123129 */
    124130int usb_release_default_address(async_exch_t *exch)
    … …  
    131137
    132138/** Trigger USB device enumeration
    133  * @param[in] exch IPC communication exchange
     139 *
     140 * @param[in]  exch   IPC communication exchange
    134141 * @param[out] handle Identifier of the newly added device (if successful)
     142 *
    135143 * @return Error code.
     144 *
    136145 */
    137146int usb_device_enumerate(async_exch_t *exch, unsigned port)
    … …  
    145154
    146155/** Trigger USB device enumeration
    147  * @param[in] exch IPC communication exchange
     156 *
     157 * @param[in] exch   IPC communication exchange
    148158 * @param[in] handle Identifier of the device
     159 *
    149160 * @return Error code.
     161 *
    150162 */
    151163int usb_device_remove(async_exch_t *exch, unsigned port)

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

    r7a67416 r58563585  
    4444typedef async_sess_t usb_dev_session_t;
    4545
    46 usb_dev_session_t *usb_dev_connect(devman_handle_t);
    47 usb_dev_session_t *usb_dev_connect_to_self(ddf_dev_t *);
    48 void usb_dev_disconnect(usb_dev_session_t *);
     46extern usb_dev_session_t *usb_dev_connect(devman_handle_t);
     47extern usb_dev_session_t *usb_dev_connect_to_self(ddf_dev_t *);
     48extern void usb_dev_disconnect(usb_dev_session_t *);
    4949
    50 int usb_get_my_interface(async_exch_t *, int *);
    51 int usb_get_my_device_handle(async_exch_t *, devman_handle_t *);
     50extern int usb_get_my_interface(async_exch_t *, int *);
     51extern int usb_get_my_device_handle(async_exch_t *, devman_handle_t *);
    5252
    53 int usb_reserve_default_address(async_exch_t *, usb_speed_t);
    54 int usb_release_default_address(async_exch_t *);
     53extern int usb_reserve_default_address(async_exch_t *, usb_speed_t);
     54extern int usb_release_default_address(async_exch_t *);
    5555
    56 int usb_device_enumerate(async_exch_t *, unsigned port);
    57 int usb_device_remove(async_exch_t *, unsigned port);
     56extern int usb_device_enumerate(async_exch_t *, unsigned port);
     57extern int usb_device_remove(async_exch_t *, unsigned port);
    5858
    59 int usb_register_endpoint(async_exch_t *, usb_endpoint_t, usb_transfer_type_t,
    60     usb_direction_t, size_t, unsigned, unsigned);
    61 int usb_unregister_endpoint(async_exch_t *, usb_endpoint_t, usb_direction_t);
    62 int usb_read(async_exch_t *, usb_endpoint_t, uint64_t, void *, size_t, size_t *);
    63 int usb_write(async_exch_t *, usb_endpoint_t, uint64_t, const void *, size_t);
     59extern int usb_register_endpoint(async_exch_t *, usb_endpoint_t,
     60    usb_transfer_type_t, usb_direction_t, size_t, unsigned, unsigned);
     61extern int usb_unregister_endpoint(async_exch_t *, usb_endpoint_t,
     62    usb_direction_t);
     63extern int usb_read(async_exch_t *, usb_endpoint_t, uint64_t, void *, size_t,
     64    size_t *);
     65extern int usb_write(async_exch_t *, usb_endpoint_t, uint64_t, const void *,
     66    size_t);
    6467
    6568/** Callback for outgoing transfer. */

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

    r7a67416 r58563585  
    4444#include <stdbool.h>
    4545
    46 int usbhc_read(async_exch_t *, usb_address_t, usb_endpoint_t,
     46extern int usbhc_read(async_exch_t *, usb_address_t, usb_endpoint_t,
    4747    uint64_t, void *, size_t, size_t *);
    48 int usbhc_write(async_exch_t *, usb_address_t, usb_endpoint_t,
     48extern int usbhc_write(async_exch_t *, usb_address_t, usb_endpoint_t,
    4949    uint64_t, const void *, size_t);
    5050

  • uspace/lib/math/arch/amd64/src/sin.S

    r7a67416 r58563585  
    7777        retq
    7878FUNCTION_END(sin_f64)
    79 

  • uspace/lib/math/arch/ia32/src/cos.S

    r7a67416 r58563585  
    6464        ret
    6565FUNCTION_END(cos_f64)
    66 

  • uspace/lib/math/arch/ia32/src/sin.S

    r7a67416 r58563585  
    6464        ret
    6565FUNCTION_END(sin_f64)
    66 

  • uspace/lib/math/arch/ia32/src/trunc.S

    r7a67416 r58563585  
    6161        ret
    6262FUNCTION_END(trunc_f64)
    63 

  • uspace/lib/usb/include/usb/classes/hub.h

    r7a67416 r58563585  
    110110         */
    111111        uint8_t characteristics;
     112
    112113#define HUB_CHAR_POWER_PER_PORT_FLAG    (1 << 0)
    113114#define HUB_CHAR_NO_POWER_SWITCH_FLAG   (1 << 1)
    … …  
    196197 */
    197198/* 7 (basic size) + 2*32 (port bitmasks) */
    198 #define USB_HUB_MAX_DESCRIPTOR_SIZE (7 + 2 * 32)
     199#define USB_HUB_MAX_DESCRIPTOR_SIZE  (7 + 2 * 32)
    199200
    200201#endif

  • uspace/lib/usb/include/usb/debug.h

    r7a67416 r58563585  
    3838#include <sys/types.h>
    3939#include <io/log.h>
    40 
    4140
    4241void usb_dump_standard_descriptor(FILE *, const char *, const char *,

  • uspace/lib/usb/include/usb/descriptor.h

    r7a67416 r58563585  
    4545        USB_DESCTYPE_INTERFACE = 4,
    4646        USB_DESCTYPE_ENDPOINT = 5,
    47         /* New in USB2.0 */
     47        /* New in USB 2.0 */
    4848        USB_DESCTYPE_DEVICE_QUALIFIER = 6,
    4949        USB_DESCTYPE_OTHER_SPEED_CONFIGURATION = 7,
    … …  
    202202         * HS INT and ISO transfers. */
    203203        uint16_t max_packet_size;
     204
    204205#define ED_MPS_PACKET_SIZE_MASK  0x3ff
    205206#define ED_MPS_PACKET_SIZE_GET(value) \
    … …  
    207208#define ED_MPS_TRANS_OPPORTUNITIES_GET(value) \
    208209        ((((value) >> 10) & 0x3) + 1)
     210
    209211        /** Polling interval in milliseconds.
    210212         * Ignored for bulk and control endpoints.

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

    r7a67416 r58563585  
    2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2727 */
     28
    2829/** @addtogroup libusb
    2930 * @{
    3031 */
     32
    3133/** @file
    3234 * Common USB types and functions.
    3335 */
     36
    3437#ifndef LIBUSB_DEV_H_
    3538#define LIBUSB_DEV_H_
    … …  
    3740#include <devman.h>
    3841
    39 int usb_resolve_device_handle(const char *, devman_handle_t *);
     42extern int usb_resolve_device_handle(const char *, devman_handle_t *);
     43
    4044#endif
     45
    4146/**
    4247 * @}

  • uspace/lib/usb/include/usb/usb.h

    r7a67416 r58563585  
    114114/** Default USB address. */
    115115#define USB_ADDRESS_DEFAULT 0
     116
    116117/** Maximum address number in USB 1.1. */
    117118#define USB11_ADDRESS_MAX 127
    … …  
    121122 *
    122123 * @param ep USB address.
     124 *
    123125 * @return True, if value is wihtin limits, false otherwise.
     126 *
    124127 */
    125128static inline bool usb_address_is_valid(usb_address_t a)
    … …  
    135138/** Default control endpoint */
    136139#define USB_ENDPOINT_DEFAULT_CONTROL 0
     140
    137141/** Maximum endpoint number in USB 1.1. */
    138142#define USB11_ENDPOINT_MAX 16
    … …  
    141145 *
    142146 * @param ep USB endpoint number.
     147 *
    143148 * @return True, if value is wihtin limits, false otherwise.
     149 *
    144150 */
    145151static inline bool usb_endpoint_is_valid(usb_endpoint_t ep)
    … …  
    160166        uint32_t packed;
    161167} usb_target_t;
    162 
    163168
    164169/** Check USB target for allowed values (address and endpoint).

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

    r7a67416 r58563585  
    121121 *
    122122 * @param[in] requst Setup requst data.
     123 *
    123124 * @retval -1 No endpoints need reset.
    124125 * @retval 0 All endpoints need reset.
    125126 * @retval >0 Specified endpoint needs reset.
     127 *
    126128 */
    127129int usb_request_needs_toggle_reset(

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

    r7a67416 r58563585  
    9494typedef void (*usb_polling_terminted_callback_t)(usb_device_t *, bool, void *);
    9595
    96 int usb_device_auto_polling(usb_device_t *, usb_endpoint_t,
     96extern int usb_device_auto_polling(usb_device_t *, usb_endpoint_t,
    9797    const usb_device_auto_polling_t *, size_t);
    9898
    99 int usb_device_auto_poll(usb_device_t *, usb_endpoint_t,
     99extern int usb_device_auto_poll(usb_device_t *, usb_endpoint_t,
    100100    usb_polling_callback_t, size_t, int, usb_polling_terminted_callback_t, void *);
    101101
    102 int usb_device_auto_polling_desc(usb_device_t *,
     102extern int usb_device_auto_polling_desc(usb_device_t *,
    103103    const usb_endpoint_description_t *, const usb_device_auto_polling_t *,
    104104    size_t);
    105105
    106 int usb_device_auto_poll_desc(usb_device_t *,
     106extern int usb_device_auto_poll_desc(usb_device_t *,
    107107    const usb_endpoint_description_t *, usb_polling_callback_t, size_t, int,
    108108    usb_polling_terminted_callback_t, void *);

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

    r7a67416 r58563585  
    5050
    5151extern int usb_device_create_match_ids(usb_pipe_t *, match_id_list_t *);
     52
    5253#endif
    5354

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

    r7a67416 r58563585  
    2727 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    2828 */
     29
    2930/** @addtogroup libusbdev
    3031 * @{
    … …  
    5556        /** Connection to device on USB bus */
    5657        usb_dev_session_t *bus_session;
     58       
    5759        /** devman handle */
    5860        devman_handle_t handle;
     61       
    5962        /** The default control pipe. */
    6063        usb_pipe_t ctrl_pipe;
    61 
     64       
    6265        /** Other endpoint pipes.
     66         *
    6367         * This is an array of other endpoint pipes in the same order as
    6468         * in usb_driver_t.
    6569         */
    6670        usb_endpoint_mapping_t *pipes;
     71       
    6772        /** Number of other endpoint pipes. */
    6873        size_t pipes_count;
     74       
    6975        /** Current interface.
     76         *
    7077         * Usually, drivers operate on single interface only.
    7178         * This item contains the value of the interface or -1 for any.
    7279         */
    7380        int interface_no;
     81       
    7482        /** Alternative interfaces. */
    7583        usb_alternate_interfaces_t alternate_interfaces;
     84       
    7685        /** Some useful descriptors for USB device. */
    7786        usb_device_descriptors_t descriptors;
     87       
    7888        /** Generic DDF device backing this one. DO NOT TOUCH! */
    7989        ddf_dev_t *ddf_dev;
     90       
    8091        /** Custom driver data.
     92         *
    8193         * Do not use the entry in generic device, that is already used
    8294         * by the framework.
    8395         */
    8496        void *driver_data;
    85 
    8697} usb_device_t;
    8798
    … …  
    135146                return rc;
    136147        }
    137 
     148       
    138149        /* Change current alternative */
    139150        usb_dev->alternate_interfaces.current = alternate_setting;
    … …  
    279290 *
    280291 * @param[in] usb_dev USB device.
     292 *
    281293 */
    282294void usb_device_destroy_pipes(usb_device_t *usb_dev)
    … …  
    284296        assert(usb_dev);
    285297        assert(usb_dev->pipes || usb_dev->pipes_count == 0);
     298       
    286299        /* Destroy the pipes. */
    287300        for (size_t i = 0; i < usb_dev->pipes_count; ++i) {
    … …  
    291304                        usb_pipe_unregister(&usb_dev->pipes[i].pipe);
    292305        }
     306       
    293307        free(usb_dev->pipes);
    294308        usb_dev->pipes = NULL;
    … …  
    448462        assert(handle);
    449463        assert(iface_no);
     464       
    450465        async_exch_t *exch = async_exchange_begin(sess);
    451466        if (!exch)
    452467                return EPARTY;
     468       
    453469        int ret = usb_get_my_device_handle(exch, handle);
    454470        if (ret == EOK) {
    … …  
    459475                }
    460476        }
     477       
    461478        async_exchange_end(exch);
    462479        return ret;

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

    r7a67416 r58563585  
    3333 * USB device driver framework - automatic interrupt polling.
    3434 */
     35
    3536#include <usb/dev/device.h>
    3637#include <usb/dev/pipes.h>
    … …  
    8586
    8687        if (params->debug > 0) {
    87                 const usb_endpoint_mapping_t *mapping
    88                     = data->polling_mapping;
     88                const usb_endpoint_mapping_t *mapping =
     89                    data->polling_mapping;
    8990                usb_log_debug("Poll (%p): started polling of `%s' - " \
    9091                    "interface %d (%s,%d,%d), %zuB/%zu.\n",
    … …  
    154155
    155156                /* Take a rest before next request. */
    156                 //TODO: This is broken, the time is in ms not us.
     157               
     158                // FIXME TODO: This is broken, the time is in ms not us.
    157159                // but first we need to fix drivers to actually stop using this,
    158                 // since polling dealy should be implemented in HC schedule
     160                // since polling delay should be implemented in HC schedule
    159161                async_usleep(params->delay);
    160162        }
    … …  
    213215        if (request_size == 0)
    214216                return EINVAL;
    215 
     217       
    216218        if (!epm || (epm->pipe.transfer_type != USB_TRANSFER_INTERRUPT) ||
    217219            (epm->pipe.direction != USB_DIRECTION_IN))
    218220                return EINVAL;
    219 
     221       
    220222
    221223        polling_data_t *polling_data = malloc(sizeof(polling_data_t));

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

    r7a67416 r58563585  
    9898        async_exch_t *exch = async_exchange_begin(pipe->bus_session);
    9999        size_t act_size = 0;
    100         const int rc = usb_read(exch,
    101             pipe->endpoint_no, setup_packet, buffer, buffer_size, &act_size);
     100        const int rc = usb_read(exch, pipe->endpoint_no, setup_packet, buffer,
     101            buffer_size, &act_size);
    102102        async_exchange_end(exch);
    103103

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

    r7a67416 r58563585  
    286286    usb_dev_session_t *bus_session)
    287287{
    288 
    289         if (config_descriptor == NULL) {
     288        if (config_descriptor == NULL)
    290289                return EBADMEM;
    291         }
    292         if (config_descriptor_size
    293             < sizeof(usb_standard_configuration_descriptor_t)) {
     290       
     291        if (config_descriptor_size <
     292            sizeof(usb_standard_configuration_descriptor_t)) {
    294293                return ERANGE;
    295294        }

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

    r7a67416 r58563585  
    234234                    (int) device_descriptor->product_id,
    235235                    BCD_ARGS(device_descriptor->device_version));
    236 
     236               
    237237                /* Next, without release number. */
    238238                ADD_MATCHID_OR_RETURN(matches, 90,
    … …  
    245245        ADD_MATCHID_OR_RETURN(matches, 50, "usb&class=%s",
    246246            usb_str_class(device_descriptor->device_class));
    247 
     247       
    248248        /* As a last resort, try fallback driver. */
    249249        ADD_MATCHID_OR_RETURN(matches, 10, "usb&fallback");

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

    r7a67416 r58563585  
    5050 * @see usb_pipe_control_write
    5151 *
    52  * @param pipe Pipe used for the communication.
     52 * @param pipe         Pipe used for the communication.
    5353 * @param request_type Request type (standard/class/vendor).
    54  * @param recipient Request recipient (e.g. device or endpoint).
    55  * @param request Actual request (e.g. GET_DESCRIPTOR).
    56  * @param value Value of @c wValue field of setup packet
    57  *      (must be in USB endianness).
    58  * @param index Value of @c wIndex field of setup packet
    59  *      (must be in USB endianness).
    60  * @param data Data to be sent during DATA stage
    61  *      (expected to be in USB endianness).
    62  * @param data_size Size of the @p data buffer (in native endianness).
     54 * @param recipient    Request recipient (e.g. device or endpoint).
     55 * @param request      Actual request (e.g. GET_DESCRIPTOR).
     56 * @param value        Value of @c wValue field of setup packet
     57 *                     (must be in USB endianness).
     58 * @param index        Value of @c wIndex field of setup packet
     59 *                     (must be in USB endianness).
     60 * @param data         Data to be sent during DATA stage
     61 *                     (expected to be in USB endianness).
     62 * @param data_size     Size of the @p data buffer (in native endianness).
     63 *
    6364 * @return Error code.
    6465 * @retval EBADMEM @p pipe is NULL.
    6566 * @retval EBADMEM @p data is NULL and @p data_size is not zero.
    6667 * @retval ERANGE Data buffer too large.
     68 *
    6769 */
    6870int usb_control_request_set(usb_pipe_t *pipe,
    … …  
    100102}
    101103
    102  /** Generic wrapper for GET requests using standard control request format.
    103   *
    104   * @see usb_pipe_control_read
    105   *
    106   * @param pipe Pipe used for the communication.
    107   * @param request_type Request type (standard/class/vendor).
    108   * @param recipient Request recipient (e.g. device or endpoint).
    109   * @param request Actual request (e.g. GET_DESCRIPTOR).
    110   * @param value Value of @c wValue field of setup packet
    111   *     (must be in USB endianness).
    112   * @param index Value of @c wIndex field of setup packet
    113   *     (must be in USB endianness).
    114   * @param data Buffer where to store data accepted during the DATA stage.
    115   *     (they will come in USB endianness).
    116   * @param data_size Size of the @p data buffer
    117   *     (in native endianness).
    118   * @param actual_data_size Actual size of transfered data
    119   *     (in native endianness).
    120   * @return Error code.
    121   * @retval EBADMEM @p pipe is NULL.
    122   * @retval EBADMEM @p data is NULL and @p data_size is not zero.
    123   * @retval ERANGE Data buffer too large.
    124   */
     104/** Generic wrapper for GET requests using standard control request format.
     105 *
     106 * @see usb_pipe_control_read
     107 *
     108 * @param pipe             Pipe used for the communication.
     109 * @param request_type     Request type (standard/class/vendor).
     110 * @param recipient        Request recipient (e.g. device or endpoint).
     111 * @param request          Actual request (e.g. GET_DESCRIPTOR).
     112 * @param value            Value of @c wValue field of setup packet
     113 *                         (must be in USB endianness).
     114 * @param index            Value of @c wIndex field of setup packet
     115 *                         (must be in USB endianness).
     116 * @param data             Buffer where to store data accepted during
     117 *                         the DATA stage (they will come in USB endianness).
     118 * @param data_size        Size of the @p data buffer
     119 *                         (in native endianness).
     120 * @param actual_data_size Actual size of transfered data
     121 *                         (in native endianness).
     122 *
     123 * @return Error code.
     124 * @retval EBADMEM @p pipe is NULL.
     125 * @retval EBADMEM @p data is NULL and @p data_size is not zero.
     126 * @retval ERANGE Data buffer too large.
     127 *
     128 */
    125129int usb_control_request_get(usb_pipe_t *pipe,
    126130    usb_request_type_t request_type, usb_request_recipient_t recipient,
    … …  
    209213{
    210214        if (request_type == USB_REQUEST_TYPE_STANDARD) {
    211                 if ((recipient == USB_REQUEST_RECIPIENT_DEVICE) && (index != 0))
    212                 {
     215                if ((recipient == USB_REQUEST_RECIPIENT_DEVICE) && (index != 0)) {
    213216                        return EINVAL;
    214217                }
    … …  
    234237{
    235238        if (request_type == USB_REQUEST_TYPE_STANDARD) {
    236                 if ((recipient == USB_REQUEST_RECIPIENT_DEVICE) && (index != 0))
    237                 {
     239                if ((recipient == USB_REQUEST_RECIPIENT_DEVICE) && (index != 0)) {
    238240                        return EINVAL;
    239241                }
    … …  
    271273        }
    272274
    273         /* The wValue field specifies the descriptor type in the high byte
     275        /*
     276         * The wValue field specifies the descriptor type in the high byte
    274277         * and the descriptor index in the low byte. USB 1.1 spec p. 189
    275278         */

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

    r7a67416 r58563585  
    8888} endpoint_t;
    8989
    90 endpoint_t * endpoint_create(usb_address_t address, usb_endpoint_t endpoint,
    91     usb_direction_t direction, usb_transfer_type_t type, usb_speed_t speed,
    92     size_t max_packet_size, unsigned packets, size_t bw,
    93     usb_address_t tt_address, unsigned tt_port);
    94 void endpoint_destroy(endpoint_t *instance);
     90extern endpoint_t *endpoint_create(usb_address_t, usb_endpoint_t,
     91    usb_direction_t, usb_transfer_type_t, usb_speed_t, size_t, unsigned int,
     92    size_t, usb_address_t, unsigned int);
     93extern void endpoint_destroy(endpoint_t *);
    9594
    96 void endpoint_add_ref(endpoint_t *instance);
    97 void endpoint_del_ref(endpoint_t *instance);
     95extern void endpoint_add_ref(endpoint_t *);
     96extern void endpoint_del_ref(endpoint_t *);
    9897
    99 void endpoint_set_hc_data(endpoint_t *instance,
    100     void *data, int (*toggle_get)(void *), void (*toggle_set)(void *, int));
    101 void endpoint_clear_hc_data(endpoint_t *instance);
     98extern void endpoint_set_hc_data(endpoint_t *, void *, int (*)(void *),
     99    void (*)(void *, int));
     100extern void endpoint_clear_hc_data(endpoint_t *);
    102101
    103 void endpoint_use(endpoint_t *instance);
    104 void endpoint_release(endpoint_t *instance);
     102extern void endpoint_use(endpoint_t *);
     103extern void endpoint_release(endpoint_t *);
    105104
    106 int endpoint_toggle_get(endpoint_t *instance);
    107 void endpoint_toggle_set(endpoint_t *instance, int toggle);
     105extern int endpoint_toggle_get(endpoint_t *);
     106extern void endpoint_toggle_set(endpoint_t *, int);
    108107
    109108/** list_get_instance wrapper.
     109 *
    110110 * @param item Pointer to link member.
     111 *
    111112 * @return Pointer to endpoint_t structure.
     113 *
    112114 */
    113115static inline endpoint_t * endpoint_get_instance(link_t *item)
    … …  
    116118}
    117119#endif
     120
    118121/**
    119122 * @}

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

    r7a67416 r58563585  
    8181};
    8282
    83 void hcd_init(hcd_t *hcd, usb_speed_t max_speed, size_t bandwidth,
    84     bw_count_func_t bw_count);
     83extern void hcd_init(hcd_t *, usb_speed_t, size_t, bw_count_func_t);
    8584
    8685static inline void hcd_set_implementation(hcd_t *hcd, void *data,
    … …  
    102101}
    103102
    104 usb_address_t hcd_request_address(hcd_t *hcd, usb_speed_t speed);
     103extern usb_address_t hcd_request_address(hcd_t *, usb_speed_t);
    105104
    106 int hcd_release_address(hcd_t *hcd, usb_address_t address);
     105extern int hcd_release_address(hcd_t *, usb_address_t);
    107106
    108 int hcd_reserve_default_address(hcd_t *hcd, usb_speed_t speed);
     107extern int hcd_reserve_default_address(hcd_t *, usb_speed_t);
    109108
    110109static inline int hcd_release_default_address(hcd_t *hcd)
    … …  
    113112}
    114113
    115 int hcd_add_ep(hcd_t *hcd, usb_target_t target, usb_direction_t dir,
    116     usb_transfer_type_t type, size_t max_packet_size, unsigned packets,
    117     size_t size, usb_address_t tt_address, unsigned tt_port);
     114extern int hcd_add_ep(hcd_t *, usb_target_t, usb_direction_t,
     115    usb_transfer_type_t, size_t, unsigned int, size_t, usb_address_t,
     116    unsigned int);
    118117
    119 int hcd_remove_ep(hcd_t *hcd, usb_target_t target, usb_direction_t dir);
     118extern int hcd_remove_ep(hcd_t *, usb_target_t, usb_direction_t);
    120119
    121 int hcd_send_batch(hcd_t *hcd, usb_target_t target, usb_direction_t direction,
    122     void *data, size_t size, uint64_t setup_data,
    123     usbhc_iface_transfer_in_callback_t in,
    124     usbhc_iface_transfer_out_callback_t out, void *arg, const char* name);
     120extern int hcd_send_batch(hcd_t *, usb_target_t, usb_direction_t, void *,
     121    size_t, uint64_t, usbhc_iface_transfer_in_callback_t,
     122    usbhc_iface_transfer_out_callback_t, void *, const char *);
    125123
    126 ssize_t hcd_send_batch_sync(hcd_t *hcd, usb_target_t target,
    127     usb_direction_t dir, void *data, size_t size, uint64_t setup_data,
    128     const char* name);
     124extern ssize_t hcd_send_batch_sync(hcd_t *, usb_target_t, usb_direction_t,
     125    void *, size_t, uint64_t, const char *);
    129126
    130127#endif
     128
    131129/**
    132130 * @}

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

    r7a67416 r58563585  
    5656 * @return Pointer to valid usb_transfer_batch_t structure, NULL on failure.
    5757 */
    58 usb_transfer_batch_t * usb_transfer_batch_create(
    59     endpoint_t *ep,
    60     char *buffer,
     58usb_transfer_batch_t *usb_transfer_batch_create(endpoint_t *ep, char *buffer,
    6159    size_t buffer_size,
    6260    uint64_t setup_buffer,
    6361    usbhc_iface_transfer_in_callback_t func_in,
    6462    usbhc_iface_transfer_out_callback_t func_out,
    65     void *arg
    66     )
     63    void *arg)
    6764{
    6865        if (func_in == NULL && func_out == NULL)

  • uspace/lib/usbvirt/include/usbvirt/device.h

    r7a67416 r58563585  
    4141#include <async.h>
    4242#include <errno.h>
    43 
    4443
    4544/** Maximum number of endpoints supported by virtual USB. */
    … …  
    240239};
    241240
    242 
    243 int req_nop(usbvirt_device_t *device,
     241extern int req_nop(usbvirt_device_t *device,
    244242    const usb_device_request_setup_packet_t *setup_packet,
    245243    uint8_t *data, size_t *act_size);
    246244
    247 int usbvirt_device_plug(usbvirt_device_t *, const char *);
    248 void usbvirt_device_unplug(usbvirt_device_t *);
    249 
    250 void usbvirt_control_reply_helper(const usb_device_request_setup_packet_t *,
    251     uint8_t *, size_t *, const void *, size_t);
    252 
    253 int usbvirt_control_write(usbvirt_device_t *, const void *, size_t, void *, size_t);
    254 int usbvirt_control_read(usbvirt_device_t *, const void *, size_t, void *, size_t, size_t *);
    255 int usbvirt_data_out(usbvirt_device_t *, usb_transfer_type_t, usb_endpoint_t,
     245extern int usbvirt_device_plug(usbvirt_device_t *, const char *);
     246extern void usbvirt_device_unplug(usbvirt_device_t *);
     247
     248extern void usbvirt_control_reply_helper(
     249    const usb_device_request_setup_packet_t *, uint8_t *, size_t *,
    256250    const void *, size_t);
    257 int usbvirt_data_in(usbvirt_device_t *, usb_transfer_type_t, usb_endpoint_t,
     251
     252extern int usbvirt_control_write(usbvirt_device_t *, const void *, size_t,
     253    void *, size_t);
     254extern int usbvirt_control_read(usbvirt_device_t *, const void *, size_t,
    258255    void *, size_t, size_t *);
     256extern int usbvirt_data_out(usbvirt_device_t *, usb_transfer_type_t,
     257    usb_endpoint_t, const void *, size_t);
     258extern int usbvirt_data_in(usbvirt_device_t *, usb_transfer_type_t,
     259    usb_endpoint_t, void *, size_t, size_t *);
    259260
    260261#endif

  • uspace/lib/usbvirt/src/ctrltransfer.c

    r7a67416 r58563585  
    6060                return EFORWARD;
    6161        }
     62       
    6263        const usbvirt_control_request_handler_t *handler = control_handlers;
    6364        for (;handler->callback != NULL; ++handler) {
Note: See TracChangeset for help on using the changeset viewer.