Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset ba72f2b in mainline


Ignore:
Timestamp:
2011-12-10T11:02:51Z (10 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master
Children:
6843a9c
Parents:
46d9d13
Message:

sb16: User parsed variant of hw_res.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/audio/sb16/main.c

    r46d9d13 rba72f2b  
    3636#include <ddf/interrupt.h>
    3737#include <ddf/log.h>
    38 #include <device/hw_res.h>
     38#include <device/hw_res_parsed.h>
    3939#include <devman.h>
    4040#include <assert.h>
     
    165165{
    166166        assert(device);
    167         assert(sb_regs);
    168         assert(sb_regs_size);
    169         assert(mpu_regs);
    170         assert(mpu_regs_size);
    171         assert(irq);
    172         assert(dma8);
    173         assert(dma16);
    174167
    175168        async_sess_t *parent_sess =
     
    179172                return ENOMEM;
    180173
    181         hw_resource_list_t hw_resources;
    182         const int rc = hw_res_get_resource_list(parent_sess, &hw_resources);
    183         if (rc != EOK) {
    184                 async_hangup(parent_sess);
    185                 return rc;
    186         }
    187 
    188         size_t i;
    189         for (i = 0; i < hw_resources.count; i++) {
    190                 const hw_resource_t *res = &hw_resources.resources[i];
    191                 switch (res->type) {
    192                 case INTERRUPT:
    193                         *irq = res->res.interrupt.irq;
    194                         ddf_log_debug("Found interrupt: %d.\n", *irq);
    195                         break;
    196                 case IO_RANGE:
    197                         ddf_log_debug("Found io: %" PRIx64" %zu.\n",
    198                             res->res.io_range.address, res->res.io_range.size);
    199                         if (res->res.io_range.size >= sizeof(sb16_regs_t)) {
    200                                 *sb_regs = res->res.io_range.address;
    201                                 *sb_regs_size = res->res.io_range.size;
    202                         } else {
    203                                 *mpu_regs = res->res.io_range.address;
    204                                 *mpu_regs_size = res->res.io_range.size;
     174        hw_res_list_parsed_t hw_res;
     175        hw_res_list_parsed_init(&hw_res);
     176        const int ret = hw_res_get_list_parsed(parent_sess, &hw_res, 0);
     177        async_hangup(parent_sess);
     178        if (ret != EOK) {
     179                return ret;
     180        }
     181
     182        /* 1x IRQ, 1-2x DMA(8,16), 1-2x IO (MPU is separate). */
     183        if (hw_res.irqs.count != 1 ||
     184           (hw_res.io_ranges.count != 1 && hw_res.io_ranges.count != 2) ||
     185           (hw_res.dma_channels.count != 1 && hw_res.dma_channels.count != 2)) {
     186                hw_res_list_parsed_clean(&hw_res);
     187                return EINVAL;
     188        }
     189
     190        if (irq)
     191                *irq = hw_res.irqs.irqs[0];
     192
     193        if (dma8) {
     194                if (hw_res.dma_channels.channels[0] < 4) {
     195                        *dma8 = hw_res.dma_channels.channels[0];
     196                } else {
     197                        if (hw_res.dma_channels.count == 2 &&
     198                            hw_res.dma_channels.channels[1] < 4) {
     199                                *dma8 = hw_res.dma_channels.channels[1];
    205200                        }
    206                         break;
    207                 case DMA_CHANNEL_16:
    208                         *dma16 = res->res.dma_channel.dma16;
    209                         ddf_log_debug("Found DMA16 channel: %d.\n", *dma16);
    210                         break;
    211                 case DMA_CHANNEL_8:
    212                         *dma8 = res->res.dma_channel.dma8;
    213                         ddf_log_debug("Found DMA8 channel: %d.\n", *dma8);
    214                 default:
    215                         break;
    216201                }
    217202        }
    218203
    219         async_hangup(parent_sess);
    220         free(hw_resources.resources);
     204        if (dma16) {
     205                if (hw_res.dma_channels.channels[0] > 4) {
     206                        *dma16 = hw_res.dma_channels.channels[0];
     207                } else {
     208                        if (hw_res.dma_channels.count == 2 &&
     209                            hw_res.dma_channels.channels[1] > 4) {
     210                                *dma16 = hw_res.dma_channels.channels[1];
     211                        }
     212                }
     213        }
     214
     215
     216        if (hw_res.io_ranges.count == 1) {
     217                if (sb_regs)
     218                        *sb_regs = hw_res.io_ranges.ranges[0].address;
     219                if (sb_regs_size)
     220                        *sb_regs_size = hw_res.io_ranges.ranges[0].size;
     221        } else {
     222                const int sb =
     223                    (hw_res.io_ranges.ranges[0].size >= sizeof(sb16_regs_t))
     224                        ? 1 : 0;
     225                const int mpu = 1 - sb;
     226                if (sb_regs)
     227                        *sb_regs = hw_res.io_ranges.ranges[sb].address;
     228                if (sb_regs_size)
     229                        *sb_regs_size = hw_res.io_ranges.ranges[sb].size;
     230                if (mpu_regs)
     231                        *sb_regs = hw_res.io_ranges.ranges[mpu].address;
     232                if (mpu_regs_size)
     233                        *sb_regs_size = hw_res.io_ranges.ranges[mpu].size;
     234        }
     235
    221236        return EOK;
    222237}
Note: See TracChangeset for help on using the changeset viewer.