Changeset 5856b627 in mainline for uspace/lib


Ignore:
Timestamp:
2013-08-20T12:36:48Z (12 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
26e2de3
Parents:
0ee999d (diff), 4da8fdb (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Mainline changes.

Location:
uspace/lib
Files:
16 added
22 edited

Legend:

Unmodified
Added
Removed

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

    r0ee999d r5856b627  
    22812281bool async_data_read_receive(ipc_callid_t *callid, size_t *size)
    22822282{
     2283        ipc_call_t data;
     2284        return async_data_read_receive_call(callid, &data, size);
     2285}
     2286
     2287/** Wrapper for receiving the IPC_M_DATA_READ calls using the async framework.
     2288 *
     2289 * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ
     2290 * calls so that the user doesn't have to remember the meaning of each IPC
     2291 * argument.
     2292 *
     2293 * So far, this wrapper is to be used from within a connection fibril.
     2294 *
     2295 * @param callid Storage for the hash of the IPC_M_DATA_READ.
     2296 * @param size   Storage for the maximum size. Can be NULL.
     2297 *
     2298 * @return True on success, false on failure.
     2299 *
     2300 */
     2301bool async_data_read_receive_call(ipc_callid_t *callid, ipc_call_t *data,
     2302    size_t *size)
     2303{
    22832304        assert(callid);
    2284        
    2285         ipc_call_t data;
    2286         *callid = async_get_call(&data);
    2287        
    2288         if (IPC_GET_IMETHOD(data) != IPC_M_DATA_READ)
     2305        assert(data);
     2306       
     2307        *callid = async_get_call(data);
     2308       
     2309        if (IPC_GET_IMETHOD(*data) != IPC_M_DATA_READ)
    22892310                return false;
    22902311       
    22912312        if (size)
    2292                 *size = (size_t) IPC_GET_ARG2(data);
     2313                *size = (size_t) IPC_GET_ARG2(*data);
    22932314       
    22942315        return true;
    … …  
    23852406bool async_data_write_receive(ipc_callid_t *callid, size_t *size)
    23862407{
     2408        ipc_call_t data;
     2409        return async_data_write_receive_call(callid, &data, size);
     2410}
     2411
     2412/** Wrapper for receiving the IPC_M_DATA_WRITE calls using the async framework.
     2413 *
     2414 * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE
     2415 * calls so that the user doesn't have to remember the meaning of each IPC
     2416 * argument.
     2417 *
     2418 * So far, this wrapper is to be used from within a connection fibril.
     2419 *
     2420 * @param callid Storage for the hash of the IPC_M_DATA_WRITE.
     2421 * @param data   Storage for the ipc call data.
     2422 * @param size   Storage for the suggested size. May be NULL.
     2423 *
     2424 * @return True on success, false on failure.
     2425 *
     2426 */
     2427bool async_data_write_receive_call(ipc_callid_t *callid, ipc_call_t *data,
     2428    size_t *size)
     2429{
    23872430        assert(callid);
    2388        
    2389         ipc_call_t data;
    2390         *callid = async_get_call(&data);
    2391        
    2392         if (IPC_GET_IMETHOD(data) != IPC_M_DATA_WRITE)
     2431        assert(data);
     2432       
     2433        *callid = async_get_call(data);
     2434       
     2435        if (IPC_GET_IMETHOD(*data) != IPC_M_DATA_WRITE)
    23932436                return false;
    23942437       
    23952438        if (size)
    2396                 *size = (size_t) IPC_GET_ARG2(data);
     2439                *size = (size_t) IPC_GET_ARG2(*data);
    23972440       
    23982441        return true;

  • uspace/lib/c/generic/device/hw_res.c

    r0ee999d r5856b627  
    4242{
    4343        sysarg_t count = 0;
    44        
     44
    4545        async_exch_t *exch = async_exchange_begin(sess);
     46        if (exch == NULL)
     47                return ENOMEM;
    4648        int rc = async_req_1_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    4749            HW_RES_GET_RESOURCE_LIST, &count);
    48        
     50
    4951        if (rc != EOK) {
    5052                async_exchange_end(exch);
    5153                return rc;
    5254        }
    53        
     55
    5456        size_t size = count * sizeof(hw_resource_t);
    5557        hw_resource_t *resources = (hw_resource_t *) malloc(size);
    … …  
    5961                return ENOMEM;
    6062        }
    61        
     63
    6264        rc = async_data_read_start(exch, resources, size);
    6365        async_exchange_end(exch);
    64        
     66
    6567        if (rc != EOK) {
    6668                free(resources);
    6769                return rc;
    6870        }
    69        
     71
    7072        hw_resources->resources = resources;
    7173        hw_resources->count = count;
    72        
     74
    7375        return EOK;
    7476}
    … …  
    7779{
    7880        async_exch_t *exch = async_exchange_begin(sess);
     81        if (exch == NULL)
     82                return false;
    7983        int rc = async_req_1_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    8084            HW_RES_ENABLE_INTERRUPT);
    8185        async_exchange_end(exch);
    82        
     86
    8387        return (rc == EOK);
     88}
     89
     90/**
     91 * Setup DMA channel to specified place and mode.
     92 * @param channel DMA Channel 1,2,3 for 8 bit transfers, 5,6,7 for 16 bit.
     93 * @param pa Physical address of the buffer. Must be < 16MB for 16 bit and < 1MB
     94 *           for 8 bit transfers.
     95 * @param size DMA buffer size, limited to 64K.
     96 * @param mode Mode of the DMA channel:
     97 *              - Read or Write
     98 *              - Allow automatic reset
     99 *              - Use address decrement instead of increment
     100 *              - Use SINGLE/BLOCK/ON DEMAND transfer mode
     101 * @return Error code.
     102 */
     103int hw_res_dma_channel_setup(async_sess_t *sess,
     104    unsigned channel, uint32_t pa, uint32_t size, uint8_t mode)
     105{
     106        async_exch_t *exch = async_exchange_begin(sess);
     107        if (exch == NULL)
     108                return ENOMEM;
     109        const uint32_t packed = (channel & 0xffff) | (mode << 16);
     110        const int ret = async_req_4_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
     111            HW_RES_DMA_CHANNEL_SETUP, packed, pa, size);
     112        async_exchange_end(exch);
     113
     114        return ret;
     115}
     116
     117/**
     118 * Query remaining bytes in the buffer.
     119 * @param channel DMA Channel 1,2,3 for 8 bit transfers, 5,6,7 for 16 bit.
     120 * @return Number of bytes remaining in the buffer(>=0) or error code(<0).
     121 */
     122int hw_res_dma_channel_remain(async_sess_t *sess, unsigned channel)
     123{
     124        async_exch_t *exch = async_exchange_begin(sess);
     125        if (exch == NULL)
     126                return ENOMEM;
     127        sysarg_t remain;
     128        const int ret = async_req_2_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
     129            HW_RES_DMA_CHANNEL_REMAIN, channel, &remain);
     130        async_exchange_end(exch);
     131        if (ret == EOK)
     132                return remain;
     133        return ret;
    84134}
    85135

  • uspace/lib/c/generic/device/hw_res_parsed.c

    r0ee999d r5856b627  
    3838#include <errno.h>
    3939
    40 static void hw_res_parse_add_irq(hw_res_list_parsed_t *out, hw_resource_t *res,
    41     int flags)
     40static void hw_res_parse_add_dma_channel(hw_res_list_parsed_t *out,
     41    const hw_resource_t *res, int flags)
     42{
     43        assert(res);
     44        assert((res->type == DMA_CHANNEL_8) || (res->type == DMA_CHANNEL_16));
     45       
     46        const unsigned channel = (res->type == DMA_CHANNEL_8) ?
     47            res->res.dma_channel.dma8 : res->res.dma_channel.dma16;
     48        const size_t count = out->dma_channels.count;
     49        const int keep_duplicit = flags & HW_RES_KEEP_DUPLICIT;
     50       
     51        if (!keep_duplicit) {
     52                for (size_t i = 0; i < count; ++i) {
     53                        if (out->dma_channels.channels[i] == channel)
     54                                return;
     55                }
     56        }
     57       
     58        out->dma_channels.channels[count] = channel;
     59        ++out->dma_channels.count;
     60}
     61
     62static void hw_res_parse_add_irq(hw_res_list_parsed_t *out,
     63    const hw_resource_t *res, int flags)
    4264{
    4365        assert(res && (res->type == INTERRUPT));
    … …  
    5981
    6082static void hw_res_parse_add_io_range(hw_res_list_parsed_t *out,
    61     hw_resource_t *res, int flags)
     83    const hw_resource_t *res, int flags)
    6284{
    6385        assert(res && (res->type == IO_RANGE));
    … …  
    90112
    91113static void hw_res_parse_add_mem_range(hw_res_list_parsed_t *out,
    92     hw_resource_t *res, int flags)
     114    const hw_resource_t *res, int flags)
    93115{
    94116        assert(res && (res->type == MEM_RANGE));
    … …  
    132154 *
    133155 */
    134 int hw_res_list_parse(hw_resource_list_t *hw_resources,
     156int hw_res_list_parse(const hw_resource_list_t *hw_resources,
    135157    hw_res_list_parsed_t *out, int flags)
    136158{
    … …  
    141163        hw_res_list_parsed_clean(out);
    142164       
    143         out->irqs.irqs = malloc(res_count * sizeof(int));
    144         out->io_ranges.ranges = malloc(res_count * sizeof(io_range_t));
    145         out->mem_ranges.ranges = malloc(res_count * sizeof(mem_range_t));
     165        out->irqs.irqs = calloc(res_count, sizeof(int));
     166        out->dma_channels.channels = calloc(res_count, sizeof(int));
     167        out->io_ranges.ranges = calloc(res_count, sizeof(io_range_t));
     168        out->mem_ranges.ranges = calloc(res_count, sizeof(mem_range_t));
     169        if (!out->irqs.irqs || !out->dma_channels.channels ||
     170            !out->io_ranges.ranges || !out->mem_ranges.ranges) {
     171                hw_res_list_parsed_clean(out);
     172                return ENOMEM;
     173        }
    146174       
    147175        for (size_t i = 0; i < res_count; ++i) {
    148                 hw_resource_t *resource = &(hw_resources->resources[i]);
    149                
     176                const hw_resource_t *resource = &(hw_resources->resources[i]);
     177
    150178                switch (resource->type) {
    151179                case INTERRUPT:
    … …  
    158186                        hw_res_parse_add_mem_range(out, resource, flags);
    159187                        break;
     188                case DMA_CHANNEL_8:
     189                case DMA_CHANNEL_16:
     190                        hw_res_parse_add_dma_channel(out, resource, flags);
     191                        break;
    160192                default:
     193                        hw_res_list_parsed_clean(out);
    161194                        return EINVAL;
    162195                }
    163196        }
    164        
     197
    165198        return EOK;
    166199};

  • uspace/lib/c/generic/inet/addr.c

    r0ee999d r5856b627  
    5252};
    5353
     54static const addr48_t inet_addr48_solicited_node = {
     55        0x33, 0x33, 0xff, 0, 0, 0
     56};
     57
    5458static const inet_addr_t inet_addr_any_addr = {
    5559        .family = AF_INET,
    … …  
    7276}
    7377
     78int addr48_compare(const addr48_t a, const addr48_t b)
     79{
     80        return memcmp(a, b, 6);
     81}
     82
    7483int addr128_compare(const addr128_t a, const addr128_t b)
    7584{
    7685        return memcmp(a, b, 16);
     86}
     87
     88/** Compute solicited node MAC multicast address from target IPv6 address
     89 *
     90 * @param ip  Target IPv6 address
     91 * @param mac Solicited MAC address to be assigned
     92 *
     93 */
     94void addr48_solicited_node(const addr128_t ip, addr48_t mac)
     95{
     96        memcpy(mac, inet_addr48_solicited_node, 3);
     97        memcpy(mac + 3, ip + 13, 3);
    7798}
    7899

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

    r0ee999d r5856b627  
    399399extern int async_data_read_start(async_exch_t *, void *, size_t);
    400400extern bool async_data_read_receive(ipc_callid_t *, size_t *);
     401extern bool async_data_read_receive_call(ipc_callid_t *, ipc_call_t *, size_t *);
    401402extern int async_data_read_finalize(ipc_callid_t, const void *, size_t);
    402403
    … …  
    437438extern int async_data_write_start(async_exch_t *, const void *, size_t);
    438439extern bool async_data_write_receive(ipc_callid_t *, size_t *);
     440extern bool async_data_write_receive_call(ipc_callid_t *, ipc_call_t *, size_t *);
    439441extern int async_data_write_finalize(ipc_callid_t, void *, size_t);
    440442

  • uspace/lib/c/include/device/hw_res.h

    r0ee999d r5856b627  
    5353        HW_RES_ENABLE_INTERRUPT,
    5454        HW_RES_DMA_CHANNEL_SETUP,
     55        HW_RES_DMA_CHANNEL_REMAIN,
    5556} hw_res_method_t;
    5657
    … …  
    115116
    116117extern int hw_res_dma_channel_setup(async_sess_t *, unsigned int, uint32_t,
    117     uint16_t, uint8_t);
     118    uint32_t, uint8_t);
     119extern int hw_res_dma_channel_remain(async_sess_t *, unsigned);
    118120
    119121#endif

  • uspace/lib/c/include/device/hw_res_parsed.h

    r0ee999d r5856b627  
    139139}
    140140
    141 extern int hw_res_list_parse(hw_resource_list_t *, hw_res_list_parsed_t *, int);
     141extern int hw_res_list_parse(
     142    const hw_resource_list_t *, hw_res_list_parsed_t *, int);
    142143extern int hw_res_get_list_parsed(async_sess_t *, hw_res_list_parsed_t *, int);
    143144

  • uspace/lib/c/include/inet/addr.h

    r0ee999d r5856b627  
    7373extern void addr128(const addr128_t, addr128_t);
    7474
     75extern int addr48_compare(const addr48_t, const addr48_t);
    7576extern int addr128_compare(const addr128_t, const addr128_t);
     77
     78extern void addr48_solicited_node(const addr128_t, addr48_t);
    7679
    7780extern void host2addr128_t_be(const addr128_t, addr128_t);

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

    r0ee999d r5856b627  
    3636typedef enum {
    3737        HW_RES_DEV_IFACE = 0,
     38
     39        /** Audio device mixer interface */
     40        AUDIO_MIXER_IFACE,
     41        /** Audio device pcm buffer interface */
     42        AUDIO_PCM_BUFFER_IFACE,
     43
    3844        /** Character device interface */
    3945        CHAR_DEV_IFACE,

  • uspace/lib/drv/Makefile

    r0ee999d r5856b627  
    2929
    3030USPACE_PREFIX = ../..
    31 EXTRA_CFLAGS = -Iinclude -I$(LIBUSB_PREFIX)/include
     31EXTRA_CFLAGS = -Iinclude -I$(LIBUSB_PREFIX)/include -I$(LIBPCM_PREFIX)/include
    3232LIBRARY = libdrv
    3333
    … …  
    3838        generic/log.c \
    3939        generic/logbuf.c \
     40        generic/remote_audio_mixer.c \
     41        generic/remote_audio_pcm.c \
    4042        generic/remote_hw_res.c \
    4143        generic/remote_char_dev.c \

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

    r0ee999d r5856b627  
    4949#include "remote_usbhid.h"
    5050#include "remote_pci.h"
     51#include "remote_audio_mixer.h"
     52#include "remote_audio_pcm.h"
    5153#include "remote_ahci.h"
    5254
    53 static iface_dipatch_table_t remote_ifaces = {
     55static const iface_dipatch_table_t remote_ifaces = {
    5456        .ifaces = {
    55                 &remote_hw_res_iface,
    56                 &remote_char_dev_iface,
    57                 &remote_graph_dev_iface,
    58                 &remote_nic_iface,
    59                 &remote_pci_iface,
    60                 &remote_usb_iface,
    61                 &remote_usbhc_iface,
    62                 &remote_usbhid_iface,
    63                 &remote_clock_dev_iface,
    64                 &remote_battery_dev_iface,
    65                 &remote_ahci_iface
     57                [AUDIO_MIXER_IFACE] = &remote_audio_mixer_iface,
     58                [AUDIO_PCM_BUFFER_IFACE] = &remote_audio_pcm_iface,
     59                [HW_RES_DEV_IFACE] = &remote_hw_res_iface,
     60                [CHAR_DEV_IFACE] = &remote_char_dev_iface,
     61                [GRAPH_DEV_IFACE] = &remote_graph_dev_iface,
     62                [NIC_DEV_IFACE] = &remote_nic_iface,
     63                [PCI_DEV_IFACE] = &remote_pci_iface,
     64                [USB_DEV_IFACE] = &remote_usb_iface,
     65                [USBHC_DEV_IFACE] = &remote_usbhc_iface,
     66                [USBHID_DEV_IFACE] = &remote_usbhid_iface,
     67                [CLOCK_DEV_IFACE] = &remote_clock_dev_iface,
     68                [BATTERY_DEV_IFACE] = &remote_battery_dev_iface,
     69                [AHCI_DEV_IFACE] = &remote_ahci_iface,
    6670        }
    6771};

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

    r0ee999d r5856b627  
    11/*
    22 * Copyright (c) 2010 Lenka Trochtova
     3 * Copyright (c) 2011 Jan Vesely
    34 * All rights reserved.
    45 *
    … …  
    4344static void remote_hw_res_enable_interrupt(ddf_fun_t *, void *, ipc_callid_t,
    4445    ipc_call_t *);
     46static void remote_hw_res_dma_channel_setup(ddf_fun_t *, void *, ipc_callid_t,
     47    ipc_call_t *);
     48static void remote_hw_res_dma_channel_remain(ddf_fun_t *, void *, ipc_callid_t,
     49    ipc_call_t *);
    4550
    4651static remote_iface_func_ptr_t remote_hw_res_iface_ops [] = {
    47         &remote_hw_res_get_resource_list,
    48         &remote_hw_res_enable_interrupt
     52        [HW_RES_GET_RESOURCE_LIST] = &remote_hw_res_get_resource_list,
     53        [HW_RES_ENABLE_INTERRUPT] = &remote_hw_res_enable_interrupt,
     54        [HW_RES_DMA_CHANNEL_SETUP] = &remote_hw_res_dma_channel_setup,
     55        [HW_RES_DMA_CHANNEL_REMAIN] = &remote_hw_res_dma_channel_remain,
    4956};
    5057
    … …  
    94101}
    95102
     103static void remote_hw_res_dma_channel_setup(ddf_fun_t *fun, void *ops,
     104    ipc_callid_t callid, ipc_call_t *call)
     105{
     106        hw_res_ops_t *hw_res_ops = ops;
     107
     108        if (hw_res_ops->dma_channel_setup == NULL) {
     109                async_answer_0(callid, ENOTSUP);
     110                return;
     111        }
     112        const unsigned channel = DEV_IPC_GET_ARG1(*call) & 0xffff;
     113        const uint8_t  mode = DEV_IPC_GET_ARG1(*call) >> 16;
     114        const uint32_t address = DEV_IPC_GET_ARG2(*call);
     115        const uint32_t size = DEV_IPC_GET_ARG3(*call);
     116
     117        const int ret = hw_res_ops->dma_channel_setup(
     118            fun, channel, address, size, mode);
     119        async_answer_0(callid, ret);
     120}
     121
     122static void remote_hw_res_dma_channel_remain(ddf_fun_t *fun, void *ops,
     123    ipc_callid_t callid, ipc_call_t *call)
     124{
     125        hw_res_ops_t *hw_res_ops = ops;
     126
     127        if (hw_res_ops->dma_channel_setup == NULL) {
     128                async_answer_0(callid, ENOTSUP);
     129                return;
     130        }
     131        const unsigned channel = DEV_IPC_GET_ARG1(*call);
     132        size_t remain = 0;
     133        const int ret = hw_res_ops->dma_channel_remain(fun, channel, &remain);
     134        async_answer_1(callid, ret, remain);
     135}
    96136/**
    97137 * @}

  • uspace/lib/drv/include/ops/hw_res.h

    r0ee999d r5856b627  
    4444        hw_resource_list_t *(*get_resource_list)(ddf_fun_t *);
    4545        bool (*enable_interrupt)(ddf_fun_t *);
    46         int (*dma_channel_setup)(ddf_fun_t *, unsigned, uint32_t, uint16_t, uint8_t);
     46        int (*dma_channel_setup)(ddf_fun_t *, unsigned, uint32_t, uint32_t, uint8_t);
     47        int (*dma_channel_remain)(ddf_fun_t *, unsigned, size_t *);
    4748} hw_res_ops_t;
    4849

  • uspace/lib/posix/include/posix/stdio.h

    r0ee999d r5856b627  
    6565
    6666#define BUFSIZ  4096
    67 #define SEEK_SET  0
    68 #define SEEK_CUR  1
    69 #define SEEK_END  2
    7067
    7168typedef struct _IO_FILE FILE;

  • uspace/lib/posix/include/posix/stdlib.h

    r0ee999d r5856b627  
    4646        #define NULL  ((void *) 0)
    4747#endif
     48
     49#define RAND_MAX  714025
    4850
    4951/* Process Termination */
    … …  
    122124extern int __POSIX_DEF__(mkstemp)(char *tmpl);
    123125
     126/* Pseudo-random number generator */
     127extern int __POSIX_DEF__(rand)(void);
     128extern void __POSIX_DEF__(srand)(unsigned int seed);
     129
    124130/* Legacy Declarations */
    125131extern char *__POSIX_DEF__(mktemp)(char *tmpl);

  • uspace/lib/posix/include/posix/time.h

    r0ee999d r5856b627  
    8787extern void __POSIX_DEF__(tzset)(void);
    8888
     89/* Time */
     90extern time_t __POSIX_DEF__(time)(time_t *t);
     91
    8992/* Broken-down Time */
    9093extern struct tm *__POSIX_DEF__(gmtime_r)(const time_t *restrict timer,

  • uspace/lib/posix/include/posix/unistd.h

    r0ee999d r5856b627  
    4444#include "stddef.h"
    4545
     46#define SEEK_SET  0
     47#define SEEK_CUR  1
     48#define SEEK_END  2
     49
    4650/* Process Termination */
    4751#define _exit exit
    … …  
    7781extern ssize_t __POSIX_DEF__(read)(int fildes, void *buf, size_t nbyte);
    7882extern ssize_t __POSIX_DEF__(write)(int fildes, const void *buf, size_t nbyte);
     83extern __POSIX_DEF__(off_t) __POSIX_DEF__(lseek)(int fildes,
     84    __POSIX_DEF__(off_t) offset, int whence);
    7985extern int __POSIX_DEF__(fsync)(int fildes);
    8086extern int __POSIX_DEF__(ftruncate)(int fildes, __POSIX_DEF__(off_t) length);

  • uspace/lib/posix/source/stdlib.c

    r0ee999d r5856b627  
    394394
    395395/**
     396 * Generate a pseudo random integer in the range 0 to RAND_MAX inclusive.
     397 *
     398 * @return The pseudo random integer.
     399 */
     400int posix_rand(void)
     401{
     402        return (int) random();
     403}
     404
     405/**
     406 * Initialize a new sequence of pseudo-random integers.
     407 *
     408 * @param seed The seed of the new sequence.
     409 */
     410void posix_srand(unsigned int seed)
     411{
     412        srandom(seed);
     413}
     414
     415/**
    396416 * Creates and opens an unique temporary file from template.
    397417 *

  • uspace/lib/posix/source/time.c

    r0ee999d r5856b627  
    7474        posix_daylight = 0;
    7575        posix_timezone = 0;
     76}
     77
     78/**
     79 * Get the time in seconds
     80 *
     81 * @param t If t is non-NULL, the return value is also stored in the memory
     82 *          pointed to by t.
     83 * @return  On success, the value of time in seconds since the Epoch
     84 *          is returned. On error, (time_t)-1 is returned.
     85 */
     86time_t posix_time(time_t *t)
     87{
     88        return time(t);
    7689}
    7790

  • uspace/lib/posix/source/unistd.c

    r0ee999d r5856b627  
    221221{
    222222        return errnify(write, fildes, buf, nbyte);
     223}
     224
     225/**
     226 * Reposition read/write file offset
     227 *
     228 * @param fildes File descriptor of the opened file.
     229 * @param offset New offset in the file.
     230 * @param whence The position from which the offset argument is specified.
     231 * @return Upon successful completion, returns the resulting offset
     232 *         as measured in bytes from the beginning of the file, -1 otherwise.
     233 */
     234posix_off_t posix_lseek(int fildes, posix_off_t offset, int whence)
     235{
     236        return errnify(lseek, fildes, offset, whence);
    223237}
    224238

  • uspace/lib/softfloat/softfloat.c

    r0ee999d r5856b627  
    12651265}
    12661266
     1267
     1268float __aeabi_i2f(int i)
     1269{
     1270        return __floatsisf(i);
     1271}
     1272
     1273float __aeabi_ui2f(int i)
     1274{
     1275        return __floatunsisf(i);
     1276}
     1277
    12671278double __aeabi_i2d(int i)
    12681279{
    … …  
    12801291}
    12811292
     1293int __aeabi_f2uiz(float a)
     1294{
     1295        return __fixunssfsi(a);
     1296}
     1297
    12821298int __aeabi_d2iz(double a)
    12831299{
    … …  
    12881304{
    12891305        return __fixunsdfsi(a);
     1306}
     1307
     1308int __aeabi_fcmpge(float a, float b)
     1309{
     1310        return __gesf2(a, b);
     1311}
     1312
     1313int __aeabi_fcmpgt(float a, float b)
     1314{
     1315        return __gtsf2(a, b);
     1316}
     1317
     1318int __aeabi_fcmplt(float a, float b)
     1319{
     1320        return __ltsf2(a, b);
     1321}
     1322
     1323int __aeabi_fcmpeq(float a, float b)
     1324{
     1325        return __eqsf2(a, b);
    12901326}
    12911327

  • uspace/lib/softfloat/softfloat.h

    r0ee999d r5856b627  
    204204
    205205/* ARM EABI */
     206extern float __aeabi_i2f(int);
     207extern float __aeabi_ui2f(int);
    206208extern double __aeabi_i2d(int);
    207209extern double __aeabi_ui2d(unsigned int);
    … …  
    209211
    210212extern int __aeabi_f2iz(float);
     213extern int __aeabi_f2uiz(float);
    211214extern int __aeabi_d2iz(double);
     215
     216extern int __aeabi_fcmpge(float, float);
     217extern int __aeabi_fcmpgt(float, float);
     218extern int __aeabi_fcmplt(float, float);
     219extern int __aeabi_fcmpeq(float, float);
    212220
    213221extern int __aeabi_dcmpge(double, double);
Note: See TracChangeset for help on using the changeset viewer.