Changeset 8565a42 in mainline for uspace/lib/c/generic/device


Ignore:
Timestamp:
2018-03-02T20:34:50Z (7 years ago)
Author:
GitHub <noreply@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a1a81f69, d5e5fd1
Parents:
3061bc1 (diff), 34e1206 (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.
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:34:50)
git-committer:
GitHub <noreply@…> (2018-03-02 20:34:50)
Message:

Remove all trailing whitespace, everywhere.

See individual commit messages for details.

Location:
uspace/lib/c/generic/device
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r3061bc1 r8565a42  
    4242{
    4343        sysarg_t count = 0;
    44        
     44
    4545        async_exch_t *exch = async_exchange_begin(sess);
    46        
     46
    4747        errno_t rc = async_req_1_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    4848            HW_RES_GET_RESOURCE_LIST, &count);
    49        
     49
    5050        if (rc != EOK) {
    5151                async_exchange_end(exch);
    5252                return rc;
    5353        }
    54        
     54
    5555        size_t size = count * sizeof(hw_resource_t);
    5656        hw_resource_t *resources = (hw_resource_t *) malloc(size);
    … …  
    6060                return ENOMEM;
    6161        }
    62        
     62
    6363        rc = async_data_read_start(exch, resources, size);
    6464        async_exchange_end(exch);
    65        
     65
    6666        if (rc != EOK) {
    6767                free(resources);
    6868                return rc;
    6969        }
    70        
     70
    7171        hw_resources->resources = resources;
    7272        hw_resources->count = count;
    73        
     73
    7474        return EOK;
    7575}
    … …  
    7878{
    7979        async_exch_t *exch = async_exchange_begin(sess);
    80        
     80
    8181        errno_t rc = async_req_2_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    8282            HW_RES_ENABLE_INTERRUPT, irq);
    8383        async_exchange_end(exch);
    84        
     84
    8585        return rc;
    8686}
    … …  
    8989{
    9090        async_exch_t *exch = async_exchange_begin(sess);
    91        
     91
    9292        errno_t rc = async_req_2_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    9393            HW_RES_DISABLE_INTERRUPT, irq);
    9494        async_exchange_end(exch);
    95        
     95
    9696        return rc;
    9797}
    … …  
    100100{
    101101        async_exch_t *exch = async_exchange_begin(sess);
    102        
     102
    103103        errno_t rc = async_req_2_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    104104            HW_RES_CLEAR_INTERRUPT, irq);
    105105        async_exchange_end(exch);
    106        
     106
    107107        return rc;
    108108}
    … …  
    126126{
    127127        async_exch_t *exch = async_exchange_begin(sess);
    128        
     128
    129129        const uint32_t packed = (channel & 0xffff) | (mode << 16);
    130130        const errno_t ret = async_req_4_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    131131            HW_RES_DMA_CHANNEL_SETUP, packed, pa, size);
    132        
     132
    133133        async_exchange_end(exch);
    134        
     134
    135135        return ret;
    136136}
    … …  
    148148{
    149149        async_exch_t *exch = async_exchange_begin(sess);
    150        
     150
    151151        sysarg_t remain;
    152152        const errno_t ret = async_req_2_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    153153            HW_RES_DMA_CHANNEL_REMAIN, channel, &remain);
    154        
     154
    155155        async_exchange_end(exch);
    156        
     156
    157157        if (ret == EOK)
    158158                *rem = remain;
    159        
     159
    160160        return ret;
    161161}

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

    r3061bc1 r8565a42  
    4343        assert(res);
    4444        assert((res->type == DMA_CHANNEL_8) || (res->type == DMA_CHANNEL_16));
    45        
     45
    4646        const unsigned channel = (res->type == DMA_CHANNEL_8) ?
    4747            res->res.dma_channel.dma8 : res->res.dma_channel.dma16;
    4848        const size_t count = out->dma_channels.count;
    4949        const int keep_duplicit = flags & HW_RES_KEEP_DUPLICIT;
    50        
     50
    5151        if (!keep_duplicit) {
    5252                for (size_t i = 0; i < count; ++i) {
    … …  
    5555                }
    5656        }
    57        
     57
    5858        out->dma_channels.channels[count] = channel;
    5959        ++out->dma_channels.count;
    … …  
    6464{
    6565        assert(res && (res->type == INTERRUPT));
    66        
     66
    6767        int irq = res->res.interrupt.irq;
    6868        size_t count = out->irqs.count;
    6969        int keep_duplicit = flags & HW_RES_KEEP_DUPLICIT;
    70        
     70
    7171        if (!keep_duplicit) {
    7272                for (size_t i = 0; i < count; i++) {
    … …  
    7575                }
    7676        }
    77        
     77
    7878        out->irqs.irqs[count] = irq;
    7979        out->irqs.count++;
    … …  
    105105
    106106        assert(res && (res->type == IO_RANGE));
    107        
     107
    108108        absolute = absolutize(res->res.io_range.address,
    109109            res->res.io_range.relative, win->io.base);
    … …  
    112112        size = res->res.io_range.size;
    113113        endianness = res->res.io_range.endianness;
    114        
     114
    115115        if ((size == 0) && (!(flags & HW_RES_KEEP_ZERO_AREA)))
    116116                return;
    117        
     117
    118118        int keep_duplicit = flags & HW_RES_KEEP_DUPLICIT;
    119119        size_t count = out->io_ranges.count;
    120        
     120
    121121        if (!keep_duplicit) {
    122122                for (size_t i = 0; i < count; i++) {
    … …  
    126126                        s_address = RNGABS(out->io_ranges.ranges[i]);
    127127                        s_size = RNGSZ(out->io_ranges.ranges[i]);
    128                        
     128
    129129                        if ((absolute == s_address) && (size == s_size))
    130130                                return;
    131131                }
    132132        }
    133        
     133
    134134        RNGABS(out->io_ranges.ranges[count]) = absolute;
    135135        RNGREL(out->io_ranges.ranges[count]) = relative;
    … …  
    146146        uint64_t relative;
    147147        size_t size;
    148        
     148
    149149        assert(res && (res->type == MEM_RANGE));
    150        
     150
    151151        absolute = absolutize(res->res.mem_range.address,
    152152            res->res.mem_range.relative, win->mem.base);
    … …  
    155155        size = res->res.mem_range.size;
    156156        endianness = res->res.mem_range.endianness;
    157        
     157
    158158        if ((size == 0) && (!(flags & HW_RES_KEEP_ZERO_AREA)))
    159159                return;
    160        
     160
    161161        int keep_duplicit = flags & HW_RES_KEEP_DUPLICIT;
    162162        size_t count = out->mem_ranges.count;
    163        
     163
    164164        if (!keep_duplicit) {
    165165                for (size_t i = 0; i < count; ++i) {
    … …  
    169169                        s_address = RNGABS(out->mem_ranges.ranges[i]);;
    170170                        s_size = RNGSZ(out->mem_ranges.ranges[i]);
    171                        
     171
    172172                        if ((absolute == s_address) && (size == s_size))
    173173                                return;
    174174                }
    175175        }
    176        
     176
    177177        RNGABS(out->mem_ranges.ranges[count]) = absolute;
    178178        RNGREL(out->mem_ranges.ranges[count]) = relative;
    … …  
    199199        if (!res || !out)
    200200                return EINVAL;
    201        
     201
    202202        size_t res_count = res->count;
    203203        hw_res_list_parsed_clean(out);
    204        
     204
    205205        out->irqs.irqs = calloc(res_count, sizeof(int));
    206206        out->dma_channels.channels = calloc(res_count, sizeof(int));
    … …  
    212212                return ENOMEM;
    213213        }
    214        
     214
    215215        for (size_t i = 0; i < res_count; ++i) {
    216216                const hw_resource_t *resource = &res->resources[i];
    217                
     217
    218218                switch (resource->type) {
    219219                case INTERRUPT:
    … …  
    235235                }
    236236        }
    237        
     237
    238238        return EOK;
    239239};
    … …  
    261261        if (!hw_res_parsed)
    262262                return EBADMEM;
    263        
     263
    264264        hw_resource_list_t hw_resources;
    265265        hw_res_list_parsed_clean(hw_res_parsed);
    … …  
    269269        if (rc != EOK)
    270270                return rc;
    271        
     271
    272272        rc = hw_res_get_resource_list(sess, &hw_resources);
    273273        if (rc != EOK)
    … …  
    277277            flags);
    278278        hw_res_clean_resource_list(&hw_resources);
    279        
     279
    280280        return rc;
    281281};

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

    r3061bc1 r8565a42  
    4242{
    4343        async_exch_t *exch = async_exchange_begin(sess);
    44        
     44
    4545        aid_t req = async_send_2(exch, DEV_IFACE_ID(LED_DEV_IFACE),
    4646            LED_DEV_COLOR_SET, (sysarg_t) pixel, NULL);
    47        
     47
    4848        async_exchange_end(exch);
    49        
     49
    5050        errno_t rc;
    5151        async_wait_for(req, &rc);
    52        
     52
    5353        return (errno_t) rc;
    5454}

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

    r3061bc1 r8565a42  
    5151                return rc;
    5252        }
    53        
     53
    5454        rc = async_data_read_start(exch, pio_win, sizeof(*pio_win));
    5555        async_exchange_end(exch);
    56        
     56
    5757        return rc;
    5858}
Note: See TracChangeset for help on using the changeset viewer.