Changeset 03362fbd in mainline for uspace/drv/audio


Ignore:
Timestamp:
2013-02-09T23:14:45Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
22dfd38
Parents:
b5d2e57 (diff), 005b765 (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:

Merge mainline changes.

Conflict resulting from bool.h → stdbool.h move and ddf structs turning opaque.
Fails to boot to shell console.

Location:
uspace/drv/audio/sb16
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/audio/sb16/dsp.c

    rb5d2e57 r03362fbd  
    3434
    3535#include <as.h>
    36 #include <bool.h>
     36#include <stdbool.h>
    3737#include <ddi.h>
    3838#include <devman.h>
    … …  
    159159{
    160160        async_sess_t *sess = devman_parent_device_connect(EXCHANGE_ATOMIC,
    161             dsp->sb_dev->handle, IPC_FLAG_BLOCKING);
     161            ddf_dev_get_handle(dsp->sb_dev), IPC_FLAG_BLOCKING);
    162162
    163163        const int ret = hw_res_dma_channel_setup(sess,
    … …  
    182182        }
    183183
    184         ddf_log_verbose("Setup dma buffer at %p(%p).", buffer, pa, size);
     184        ddf_log_verbose("Setup dma buffer at %p(%p) %zu.", buffer, pa, size);
    185185        assert((uintptr_t)pa < (1 << 25));
    186186
    … …  
    301301        assert(dsp->buffer.data);
    302302        async_sess_t *sess = devman_parent_device_connect(EXCHANGE_ATOMIC,
    303             dsp->sb_dev->handle, IPC_FLAG_BLOCKING);
     303            ddf_dev_get_handle(dsp->sb_dev), IPC_FLAG_BLOCKING);
    304304
    305305        // TODO: Assumes DMA 16

  • uspace/drv/audio/sb16/main.c

    rb5d2e57 r03362fbd  
    4949
    5050static int sb_add_device(ddf_dev_t *device);
    51 static int sb_get_res(const ddf_dev_t *device, uintptr_t *sb_regs,
     51static int sb_get_res(ddf_dev_t *device, uintptr_t *sb_regs,
    5252    size_t *sb_regs_size, uintptr_t *mpu_regs, size_t *mpu_regs_size,
    5353    int *irq, int *dma8, int *dma16);
    … …  
    7575{
    7676        printf(NAME": HelenOS SB16 audio driver.\n");
    77         ddf_log_init(NAME, LVL_DEBUG2);
     77        ddf_log_init(NAME);
    7878        return ddf_driver_main(&sb_driver);
    7979}
    … …  
    8282{
    8383        assert(dev);
    84         assert(dev->driver_data);
    85         sb16_interrupt(dev->driver_data);
     84        sb16_t *sb16_dev = ddf_dev_data_get(dev);
     85        assert(sb16_dev);
     86        sb16_interrupt(sb16_dev);
    8687}
    8788
    … …  
    166167}
    167168
    168 static int sb_get_res(const ddf_dev_t *device, uintptr_t *sb_regs,
     169static int sb_get_res(ddf_dev_t *device, uintptr_t *sb_regs,
    169170    size_t *sb_regs_size, uintptr_t *mpu_regs, size_t *mpu_regs_size,
    170171    int *irq, int *dma8, int *dma16)
    … …  
    172173        assert(device);
    173174
    174         async_sess_t *parent_sess =
    175             devman_parent_device_connect(EXCHANGE_SERIALIZE, device->handle,
    176             IPC_FLAG_BLOCKING);
     175        async_sess_t *parent_sess = devman_parent_device_connect(
     176            EXCHANGE_SERIALIZE, ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
    177177        if (!parent_sess)
    178178                return ENOMEM;
    … …  
    245245int sb_enable_interrupts(ddf_dev_t *device)
    246246{
    247         async_sess_t *parent_sess =
    248             devman_parent_device_connect(EXCHANGE_SERIALIZE, device->handle,
    249             IPC_FLAG_BLOCKING);
     247        async_sess_t *parent_sess = devman_parent_device_connect(
     248            EXCHANGE_SERIALIZE, ddf_dev_get_handle(device), IPC_FLAG_BLOCKING);
    250249        if (!parent_sess)
    251250                return ENOMEM;

  • uspace/drv/audio/sb16/mixer.c

    rb5d2e57 r03362fbd  
    2828
    2929#include <assert.h>
    30 #include <bool.h>
     30#include <stdbool.h>
    3131#include <errno.h>
    3232#include <libarch/ddi.h>

  • uspace/drv/audio/sb16/mixer_iface.c

    rb5d2e57 r03362fbd  
    4141{
    4242        assert(fun);
    43         assert(fun->driver_data);
    44         const sb_mixer_t *mixer = fun->driver_data;
     43        const sb_mixer_t *mixer = ddf_fun_data_get(fun);
     44        assert(mixer);
    4545        if (name)
    4646                *name = sb_mixer_type_str(mixer->type);
    … …  
    5555{
    5656        assert(fun);
    57         assert(fun->driver_data);
    58         const sb_mixer_t *mixer = fun->driver_data;
     57        const sb_mixer_t *mixer = ddf_fun_data_get(fun);
     58        assert(mixer);
    5959        return
    6060            sb_mixer_get_control_item_info(mixer, item, name, channels);
    … …  
    6565{
    6666        assert(fun);
    67         assert(fun->driver_data);
    68         const sb_mixer_t *mixer = fun->driver_data;
     67        const sb_mixer_t *mixer = ddf_fun_data_get(fun);
     68        assert(mixer);
    6969        return sb_mixer_get_channel_info(mixer, item, channel, name, levels);
    7070}
    … …  
    8787{
    8888        assert(fun);
    89         assert(fun->driver_data);
    90         const sb_mixer_t *mixer = fun->driver_data;
     89        const sb_mixer_t *mixer = ddf_fun_data_get(fun);
     90        assert(mixer);
    9191        return sb_mixer_set_volume_level(mixer, item, channel, volume);
    9292}
    … …  
    9696{
    9797        assert(fun);
    98         assert(fun->driver_data);
    99         const sb_mixer_t *mixer = fun->driver_data;
     98        const sb_mixer_t *mixer = ddf_fun_data_get(fun);
     99        assert(mixer);
    100100        unsigned levels;
    101101        const int ret =

  • uspace/drv/audio/sb16/pcm_iface.c

    rb5d2e57 r03362fbd  
    4343{
    4444        assert(fun);
    45         assert(fun->driver_data);
    46         return fun->driver_data;
     45        sb_dsp_t *dsp = ddf_fun_data_get(fun);
     46        assert(dsp);
     47        return dsp;
    4748}
    4849

  • uspace/drv/audio/sb16/sb16.c

    rb5d2e57 r03362fbd  
    2727 */
    2828
     29#define _DDF_DATA_IMPLANT
     30
    2931#include <errno.h>
    3032#include <str_error.h>
    … …  
    115117                return ret;
    116118        }
    117         dsp_fun->driver_data = &sb->dsp;
    118         dsp_fun->ops = &sb_pcm_ops;
     119        //TODO remove data implant
     120        ddf_fun_data_implant(dsp_fun, &sb->dsp);
     121        ddf_fun_set_ops(dsp_fun, &sb_pcm_ops);
    119122        ddf_log_note("Sound blaster DSP (%x.%x) initialized.",
    120123            sb->dsp.version.major, sb->dsp.version.minor);
    … …  
    124127                ddf_log_error(
    125128                    "Failed to bind PCM function: %s.", str_error(ret));
    126                 dsp_fun->driver_data = NULL;
     129                // TODO implanted data
    127130                ddf_fun_destroy(dsp_fun);
    128131                return ret;
    … …  
    133136                ddf_log_error("Failed register PCM function in category: %s.",
    134137                    str_error(ret));
    135                 dsp_fun->driver_data = NULL;
    136                 ddf_fun_unbind(dsp_fun);
     138                ddf_fun_unbind(dsp_fun);
     139                // TODO implanted data
    137140                ddf_fun_destroy(dsp_fun);
    138141                return ret;
    … …  
    147150                ddf_log_error("Failed to create mixer function.");
    148151                ddf_fun_unbind(dsp_fun);
    149                 dsp_fun->driver_data = NULL;
     152                // TODO implanted data
    150153                ddf_fun_destroy(dsp_fun);
    151154                return ENOMEM;
    … …  
    156159                    str_error(ret));
    157160                ddf_fun_unbind(dsp_fun);
    158                 dsp_fun->driver_data = NULL;
     161                // TODO implanted data
    159162                ddf_fun_destroy(dsp_fun);
    160163                ddf_fun_destroy(mixer_fun);
    … …  
    164167        ddf_log_note("Initialized mixer: %s.",
    165168            sb_mixer_type_str(sb->mixer.type));
    166         mixer_fun->driver_data = &sb->mixer;
    167         mixer_fun->ops = &sb_mixer_ops;
     169        ddf_fun_data_implant(mixer_fun, &sb->mixer);
     170        ddf_fun_set_ops(mixer_fun, &sb_mixer_ops);
    168171
    169172        ret = ddf_fun_bind(mixer_fun);
    … …  
    171174                ddf_log_error(
    172175                    "Failed to bind mixer function: %s.", str_error(ret));
    173                 mixer_fun->driver_data = NULL;
     176                // TODO implanted data
    174177                ddf_fun_destroy(mixer_fun);
    175178
    176179                ddf_fun_unbind(dsp_fun);
    177                 dsp_fun->driver_data = NULL;
     180                // TODO implanted data
    178181                ddf_fun_destroy(dsp_fun);
    179182                return ret;
Note: See TracChangeset for help on using the changeset viewer.