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

Changeset 124f9bd in mainline


Ignore:
Timestamp:
2012-07-05T20:52:36Z (10 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial
Children:
e941bf8
Parents:
4bec78f
Message:

audio/sb16: Remove newlines from debug messages.

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

Legend:

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

    r4bec78f r124f9bd  
    120120        uint8_t *buffer = dma_create_buffer24(size);
    121121        if (buffer == NULL) {
    122                 ddf_log_error("Failed to allocate buffer.\n");
     122                ddf_log_error("Failed to allocate DMA buffer.");
    123123                return ENOMEM;
    124124        }
     
    133133                bzero(dsp->buffer.data, dsp->buffer.size);
    134134        } else {
    135                 ddf_log_error("Failed to setup DMA16 channel %s.\n",
     135                ddf_log_error("Failed to setup DMA16 channel: %s.",
    136136                    str_error(ret));
    137137                dma_destroy_buffer(buffer);
     
    171171        const int ret = sb_dsp_read(dsp, &response);
    172172        if (ret != EOK) {
    173                 ddf_log_error("Failed to read DSP reset response value.\n");
     173                ddf_log_error("Failed to read DSP reset response value.");
    174174                return ret;
    175175        }
    176176        if (response != DSP_RESET_RESPONSE) {
    177                 ddf_log_error("Invalid DSP reset response: %x.\n", response);
     177                ddf_log_error("Invalid DSP reset response: %x.", response);
    178178                return EIO;
    179179        }
     
    191191        assert(dsp);
    192192        if (dsp->event_exchange) {
     193                ddf_log_verbose("Sending interrupt event.");
    193194                async_msg_0(dsp->event_exchange, IPC_FIRST_USER_METHOD);
    194195        } else {
     
    214215
    215216        const int ret = sb_setup_buffer(dsp, *size);
    216         ddf_log_debug("Providing buffer(%u): %p, %zu B.\n",
    217             BUFFER_ID, dsp->buffer.data, dsp->buffer.size);
    218 
    219         if (ret == EOK && buffer)
    220                 *buffer = dsp->buffer.data;
    221         if (ret == EOK && size)
    222                 *size = dsp->buffer.size;
    223         if (ret == EOK && id)
    224                 *id = BUFFER_ID;
     217        if (ret == EOK) {
     218                ddf_log_debug("Providing buffer(%u): %p, %zu B.",
     219                    BUFFER_ID, dsp->buffer.data, dsp->buffer.size);
     220
     221                if (buffer)
     222                        *buffer = dsp->buffer.data;
     223                if (size)
     224                        *size = dsp->buffer.size;
     225                if (id)
     226                        *id = BUFFER_ID;
     227        }
    225228        return ret;
    226229}
     
    235238                return EBUSY;
    236239        dsp->event_session = session;
     240        ddf_log_debug("Set event session.");
    237241        return EOK;
    238242}
     
    250254                async_hangup(dsp->event_session);
    251255        dsp->event_session = NULL;
     256        ddf_log_debug("DSP buffer released.");
    252257        return EOK;
    253258}
     
    269274        /* Check supported parameters */
    270275        ddf_log_debug("Starting playback on buffer(%u): rate: %u, size: %u, "
    271             " channels: %u, signed: %s.\n", id, sampling_rate, sample_size,
     276            " channels: %u, signed: %s.", id, sampling_rate, sample_size,
    272277            channels, sign ? "YES" : "NO" );
    273278        if (id != BUFFER_ID)
     
    288293        sb_dsp_write(dsp, sampling_rate & 0xff);
    289294
    290         ddf_log_debug("Sampling rate: %hhx:%hhx.\n",
     295        ddf_log_debug("Sampling rate: %hhx:%hhx.",
    291296            sampling_rate >> 8, sampling_rate & 0xff);
    292297
  • uspace/drv/audio/sb16/main.c

    r4bec78f r124f9bd  
    103103        sb16_t *soft_state = ddf_dev_data_alloc(device, sizeof(sb16_t));
    104104        int ret = soft_state ? EOK : ENOMEM;
    105         CHECK_RET_RETURN(ret, "Failed to allocate sb16 structure.\n");
     105        CHECK_RET_RETURN(ret, "Failed to allocate sb16 structure.");
    106106
    107107        uintptr_t sb_regs = 0, mpu_regs = 0;
     
    111111        ret = sb_get_res(device, &sb_regs, &sb_regs_size, &mpu_regs,
    112112            &mpu_regs_size, &irq, &dma8, &dma16);
    113         CHECK_RET_RETURN(ret,
    114             "Failed to get resources: %s.\n", str_error(ret));
     113        CHECK_RET_RETURN(ret, "Failed to get resources: %s.", str_error(ret));
    115114
    116115        const size_t irq_cmd_count = sb16_irq_code_size();
     
    128127        ret = register_interrupt_handler(device, irq, irq_handler, &irq_code);
    129128        CHECK_RET_RETURN(ret,
    130             "Failed to register irq handler: %s.\n", str_error(ret));
     129            "Failed to register irq handler: %s.", str_error(ret));
    131130
    132131#define CHECK_RET_UNREG_DEST_RETURN(ret, msg...) \
     
    138137
    139138        ret = sb_enable_interrupts(device);
    140         CHECK_RET_UNREG_DEST_RETURN(ret, "Failed to enable interrupts: %s.\n",
     139        CHECK_RET_UNREG_DEST_RETURN(ret, "Failed to enable interrupts: %s.",
    141140            str_error(ret));
    142141
     
    144143            soft_state, (void*)sb_regs, sb_regs_size, device, dma8, dma16);
    145144        CHECK_RET_UNREG_DEST_RETURN(ret,
    146             "Failed to init sb16 driver: %s.\n", str_error(ret));
     145            "Failed to init sb16 driver: %s.", str_error(ret));
    147146
    148147        ret = sb16_init_mpu(soft_state, (void*)mpu_regs, mpu_regs_size);
     
    154153                        if (ret != EOK)
    155154                                ddf_log_error(
    156                                     "Failed to bind midi function: %s.\n",
     155                                    "Failed to bind midi function: %s.",
    157156                                    str_error(ret));
    158157                } else {
    159                         ddf_log_error("Failed to create midi function.\n");
     158                        ddf_log_error("Failed to create midi function.");
    160159                }
    161160        } else {
    162             ddf_log_warning("Failed to init mpu driver: %s.\n", str_error(ret));
     161            ddf_log_warning("Failed to init mpu driver: %s.", str_error(ret));
    163162        }
    164163
  • uspace/drv/audio/sb16/mixer.c

    r4bec78f r124f9bd  
    168168        pio_write_8(&regs->mixer_address, MIXER_PNP_DMA_ADDRESS);
    169169        const uint8_t dma = pio_read_8(&regs->mixer_data);
    170         ddf_log_debug("SB16 setup with IRQ 0x%hhx and DMA 0x%hhx.\n", irq, dma);
     170        ddf_log_debug("SB16 setup with IRQ 0x%hhx and DMA 0x%hhx.", irq, dma);
    171171        return EOK;
    172172}
     
    238238        value |= level << chan->shift;
    239239        pio_write_8(&mixer->regs->mixer_data, value);
    240         ddf_log_note("Channel %s %s volume set to: %u.\n",
     240        ddf_log_note("Channel %s %s volume set to: %u.",
    241241            volume_table[mixer->type].table[index].description,
    242242            chan->name, level);
  • uspace/drv/audio/sb16/sb16.c

    r4bec78f r124f9bd  
    9999        if (ret != EOK)
    100100                return ret;
    101         ddf_log_debug("PIO registers at %p accessible.\n", sb->regs);
     101        ddf_log_debug("PIO registers at %p accessible.", sb->regs);
    102102
    103103        /* Initialize DSP */
    104104        ddf_fun_t *dsp_fun = ddf_fun_create(dev, fun_exposed, "dsp");
    105105        if (!dsp_fun) {
    106                 ddf_log_error("Failed to create dsp function.\n");
     106                ddf_log_error("Failed to create dsp function.");
    107107                return ENOMEM;
    108108        }
     
    110110        ret = sb_dsp_init(&sb->dsp, sb->regs, dev, dma8, dma16);
    111111        if (ret != EOK) {
    112                 ddf_log_error("Failed to initialize SB DSP: %s.\n",
     112                ddf_log_error("Failed to initialize SB DSP: %s.",
    113113                    str_error(ret));
    114114                return ret;
     
    116116        dsp_fun->driver_data = &sb->dsp;
    117117        dsp_fun->ops = &sb_pcm_ops;
    118         ddf_log_note("Sound blaster DSP (%x.%x) initialized.\n",
     118        ddf_log_note("Sound blaster DSP (%x.%x) initialized.",
    119119            sb->dsp.version.major, sb->dsp.version.minor);
    120120
     
    122122        if (ret != EOK) {
    123123                ddf_log_error(
    124                     "Failed to bind DSP function: %s.\n", str_error(ret));
     124                    "Failed to bind DSP function: %s.", str_error(ret));
    125125                dsp_fun->driver_data = NULL;
    126126                ddf_fun_destroy(dsp_fun);
     
    134134        ddf_fun_t *mixer_fun = ddf_fun_create(dev, fun_exposed, "mixer");
    135135        if (!mixer_fun) {
    136                 ddf_log_error("Failed to create mixer function.\n");
     136                ddf_log_error("Failed to create mixer function.");
    137137                ddf_fun_unbind(dsp_fun);
    138138                dsp_fun->driver_data = NULL;
     
    142142        ret = sb_mixer_init(&sb->mixer, sb->regs, mixer_type);
    143143        if (ret != EOK) {
    144                 ddf_log_error("Failed to initialize SB mixer: %s.\n",
     144                ddf_log_error("Failed to initialize SB mixer: %s.",
    145145                    str_error(ret));
    146146                ddf_fun_unbind(dsp_fun);
     
    151151        }
    152152
    153         ddf_log_note("Initialized mixer: %s.\n",
     153        ddf_log_note("Initialized mixer: %s.",
    154154            sb_mixer_type_str(sb->mixer.type));
    155155        mixer_fun->driver_data = &sb->mixer;
     
    159159        if (ret != EOK) {
    160160                ddf_log_error(
    161                     "Failed to bind mixer function: %s.\n", str_error(ret));
     161                    "Failed to bind mixer function: %s.", str_error(ret));
    162162                mixer_fun->driver_data = NULL;
    163163                ddf_fun_destroy(mixer_fun);
     
    192192                }
    193193        } else {
    194                 ddf_log_debug("SB16 interrupt.\n");
     194                ddf_log_debug("SB16 interrupt.");
    195195        }
    196196        sb_dsp_interrupt(&sb->dsp);
Note: See TracChangeset for help on using the changeset viewer.