Changes in / [6843a9c:0bbd13e] in mainline


Ignore:
Files:
31 deleted
11 edited

Legend:

Unmodified
Added
Removed

  • boot/Makefile.common

    r6843a9c r0bbd13e  
    155155        $(USPACE_PATH)/app/dltest2/dltest2 \
    156156        $(USPACE_PATH)/app/dload/dload \
    157         $(USPACE_PATH)/app/dplay/dplay \
    158157        $(USPACE_PATH)/app/edit/edit \
    159158        $(USPACE_PATH)/app/ext2info/ext2info \
    … …  
    162161        $(USPACE_PATH)/app/killall/killall \
    163162        $(USPACE_PATH)/app/loc/loc \
    164         $(USPACE_PATH)/app/mixerctl/mixerctl \
    165163        $(USPACE_PATH)/app/mkfat/mkfat \
    166164        $(USPACE_PATH)/app/mkexfat/mkexfat \

  • boot/arch/amd64/Makefile.inc

    r6843a9c r0bbd13e  
    3535
    3636RD_DRVS += \
    37         audio/sb16 \
    38         char/ns8250 \
    3937        infrastructure/rootpc \
    4038        bus/pci/pciintel \

  • uspace/Makefile

    r6843a9c r0bbd13e  
    3838        app/bnchmark \
    3939        app/devctl \
    40         app/dplay \
    4140        app/edit \
    4241        app/ext2info \
    … …  
    4948        app/loc \
    5049        app/lsusb \
    51         app/mixerctl \
    5250        app/mkfat \
    5351        app/mkexfat \
    … …  
    105103        srv/hid/remcons \
    106104        srv/hw/char/s3c24xx_uart \
    107         drv/audio/sb16 \
    108105        drv/infrastructure/root \
    109106        drv/infrastructure/rootvirt \

  • uspace/drv/bus/isa/isa.c

    r6843a9c r0bbd13e  
    9191        fibril_mutex_t mutex;
    9292        ddf_fun_t *fnode;
    93         hw_resource_t resources[ISA_MAX_HW_RES];
    9493        hw_resource_list_t hw_resources;
    9594        link_t bus_link;
    … …  
    208207
    209208        fibril_mutex_initialize(&fun->mutex);
    210         fun->hw_resources.resources = fun->resources;
    211 
    212209        fun->fnode = fnode;
    213210        return fun;
    … …  
    521518}
    522519
     520static void fun_hw_res_alloc(isa_fun_t *fun)
     521{
     522        fun->hw_resources.resources =
     523            (hw_resource_t *) malloc(sizeof(hw_resource_t) * ISA_MAX_HW_RES);
     524}
     525
     526static void fun_hw_res_free(isa_fun_t *fun)
     527{
     528        free(fun->hw_resources.resources);
     529        fun->hw_resources.resources = NULL;
     530}
     531
    523532static char *isa_fun_read_info(char *fun_conf, isa_bus_t *isa)
    524533{
    … …  
    549558                return NULL;
    550559        }
     560
     561        /* Allocate buffer for the list of hardware resources of the device. */
     562        fun_hw_res_alloc(fun);
    551563
    552564        /* Get properties of the device (match ids, irq and io range). */
    … …  
    665677                list_remove(&fun->bus_link);
    666678
     679                fun_hw_res_free(fun);
    667680                ddf_fun_destroy(fun->fnode);
    668681        }

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

    r6843a9c r0bbd13e  
    4242{
    4343        sysarg_t count = 0;
    44 
     44       
    4545        async_exch_t *exch = async_exchange_begin(sess);
    46         if (exch == NULL)
    47                 return ENOMEM;
    4846        int rc = async_req_1_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    4947            HW_RES_GET_RESOURCE_LIST, &count);
    50 
     48       
    5149        if (rc != EOK) {
    5250                async_exchange_end(exch);
    5351                return rc;
    5452        }
    55 
     53       
    5654        size_t size = count * sizeof(hw_resource_t);
    5755        hw_resource_t *resources = (hw_resource_t *) malloc(size);
    … …  
    6159                return ENOMEM;
    6260        }
    63 
     61       
    6462        rc = async_data_read_start(exch, resources, size);
    6563        async_exchange_end(exch);
    66 
     64       
    6765        if (rc != EOK) {
    6866                free(resources);
    6967                return rc;
    7068        }
    71 
     69       
    7270        hw_resources->resources = resources;
    7371        hw_resources->count = count;
    74 
     72       
    7573        return EOK;
    7674}
    … …  
    7977{
    8078        async_exch_t *exch = async_exchange_begin(sess);
    81         if (exch == NULL)
    82                 return false;
    8379        int rc = async_req_1_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    8480            HW_RES_ENABLE_INTERRUPT);
    8581        async_exchange_end(exch);
    86 
     82       
    8783        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  */
    103 int hw_res_dma_channel_setup(async_sess_t *sess,
    104     unsigned channel, uint32_t pa, uint16_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 = size | (mode << 16);
    110         const int ret = async_req_4_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
    111             HW_RES_DMA_CHANNEL_SETUP, channel, pa, packed);
    112         async_exchange_end(exch);
    113 
    114         return ret;
    11584}
    11685

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

    r6843a9c r0bbd13e  
    3838#include <errno.h>
    3939
    40 static 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 int 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 
    62 static void hw_res_parse_add_irq(hw_res_list_parsed_t *out,
    63     const hw_resource_t *res, int flags)
     40static void hw_res_parse_add_irq(hw_res_list_parsed_t *out, hw_resource_t *res,
     41    int flags)
    6442{
    6543        assert(res && (res->type == INTERRUPT));
    … …  
    8159
    8260static void hw_res_parse_add_io_range(hw_res_list_parsed_t *out,
    83     const hw_resource_t *res, int flags)
     61    hw_resource_t *res, int flags)
    8462{
    8563        assert(res && (res->type == IO_RANGE));
    … …  
    11290
    11391static void hw_res_parse_add_mem_range(hw_res_list_parsed_t *out,
    114     const hw_resource_t *res, int flags)
     92    hw_resource_t *res, int flags)
    11593{
    11694        assert(res && (res->type == MEM_RANGE));
    … …  
    154132 *
    155133 */
    156 int hw_res_list_parse(const hw_resource_list_t *hw_resources,
     134int hw_res_list_parse(hw_resource_list_t *hw_resources,
    157135    hw_res_list_parsed_t *out, int flags)
    158136{
    … …  
    163141        hw_res_list_parsed_clean(out);
    164142       
    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         }
     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));
    174146       
    175147        for (size_t i = 0; i < res_count; ++i) {
    176                 const hw_resource_t *resource = &(hw_resources->resources[i]);
    177 
     148                hw_resource_t *resource = &(hw_resources->resources[i]);
     149               
    178150                switch (resource->type) {
    179151                case INTERRUPT:
    … …  
    186158                        hw_res_parse_add_mem_range(out, resource, flags);
    187159                        break;
    188                 case DMA_CHANNEL_8:
    189                 case DMA_CHANNEL_16:
    190                         hw_res_parse_add_dma_channel(out, resource, flags);
    191                         break;
    192160                default:
    193                         hw_res_list_parsed_clean(out);
    194161                        return EINVAL;
    195162                }
    196163        }
    197 
     164       
    198165        return EOK;
    199166};

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

    r6843a9c r0bbd13e  
    100100        /** List of IRQs */
    101101        irq_list_t irqs;
    102 
    103         /** List of DMA channels */
    104         dma_list_t dma_channels;
    105102       
    106103        /** List of DMA channels */
    … …  
    142139}
    143140
    144 extern int hw_res_list_parse(
    145     const hw_resource_list_t *, hw_res_list_parsed_t *, int);
     141extern int hw_res_list_parse(hw_resource_list_t *, hw_res_list_parsed_t *, int);
    146142extern int hw_res_get_list_parsed(async_sess_t *, hw_res_list_parsed_t *, int);
    147143

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

    r6843a9c r0bbd13e  
    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 
    4438        /** Character device interface */
    4539        CHAR_DEV_IFACE,

  • uspace/lib/drv/Makefile

    r6843a9c r0bbd13e  
    3838        generic/log.c \
    3939        generic/logbuf.c \
    40         generic/remote_audio_mixer.c \
    41         generic/remote_audio_pcm_buffer.c \
    4240        generic/remote_hw_res.c \
    4341        generic/remote_char_dev.c \

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

    r6843a9c r0bbd13e  
    4646#include "remote_usbhid.h"
    4747#include "remote_pci.h"
    48 #include "remote_audio_mixer.h"
    49 #include "remote_audio_pcm_buffer.h"
    5048
    51 static const iface_dipatch_table_t remote_ifaces = {
     49static iface_dipatch_table_t remote_ifaces = {
    5250        .ifaces = {
    53                 [AUDIO_MIXER_IFACE] = &remote_audio_mixer_iface,
    54                 [AUDIO_PCM_BUFFER_IFACE] = &remote_audio_pcm_buffer_iface,
    55                 [HW_RES_DEV_IFACE] = &remote_hw_res_iface,
    56                 [CHAR_DEV_IFACE] = &remote_char_dev_iface,
    57                 [NIC_DEV_IFACE] = &remote_nic_iface,
    58                 [PCI_DEV_IFACE] = &remote_pci_iface,
    59                 [USB_DEV_IFACE] = &remote_usb_iface,
    60                 [USBHC_DEV_IFACE] = &remote_usbhc_iface,
    61                 [USBHID_DEV_IFACE] = &remote_usbhid_iface,
     51                &remote_hw_res_iface,
     52                &remote_char_dev_iface,
     53                &remote_nic_iface,
     54                &remote_pci_iface,
     55                &remote_usb_iface,
     56                &remote_usbhc_iface,
     57                &remote_usbhid_iface
    6258        }
    6359};

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

    r6843a9c r0bbd13e  
    11/*
    22 * Copyright (c) 2010 Lenka Trochtova
    3  * Copyright (c) 2011 Jan Vesely
    43 * All rights reserved.
    54 *
    … …  
    4443static void remote_hw_res_enable_interrupt(ddf_fun_t *, void *, ipc_callid_t,
    4544    ipc_call_t *);
    46 static void remote_hw_res_dma_channel_setup(ddf_fun_t *, void *, ipc_callid_t,
    47     ipc_call_t *);
    4845
    4946static remote_iface_func_ptr_t remote_hw_res_iface_ops [] = {
    50         [HW_RES_GET_RESOURCE_LIST] = &remote_hw_res_get_resource_list,
    51         [HW_RES_ENABLE_INTERRUPT] = &remote_hw_res_enable_interrupt,
    52         [HW_RES_DMA_CHANNEL_SETUP] = &remote_hw_res_dma_channel_setup,
     47        &remote_hw_res_get_resource_list,
     48        &remote_hw_res_enable_interrupt
    5349};
    5450
    … …  
    9894}
    9995
    100 static void remote_hw_res_dma_channel_setup(ddf_fun_t *fun, void *ops,
    101     ipc_callid_t callid, ipc_call_t *call)
    102 {
    103         hw_res_ops_t *hw_res_ops = ops;
    104 
    105         if (hw_res_ops->dma_channel_setup == NULL) {
    106                 async_answer_0(callid, ENOTSUP);
    107                 return;
    108         }
    109         const unsigned channel = DEV_IPC_GET_ARG1(*call);
    110         const uint32_t address = DEV_IPC_GET_ARG2(*call);
    111         const uint16_t size = DEV_IPC_GET_ARG3(*call) & 0xffff;
    112         const uint8_t mode = DEV_IPC_GET_ARG3(*call) >> 16;
    113 
    114         const int ret = hw_res_ops->dma_channel_setup(
    115             fun, channel, address, size, mode);
    116         async_answer_0(callid, ret);
    117 }
    118 
    11996/**
    12097 * @}
Note: See TracChangeset for help on using the changeset viewer.