dmic.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018, Intel Corporation
 *
 * Author:      Seppo Ingalsuo <seppo.ingalsuo@linux.intel.com>
 *              Sathish Kuttan <sathish.k.kuttan@intel.com>
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_AUDIO_DMIC_H_
#define ZEPHYR_INCLUDE_AUDIO_DMIC_H_
 


 
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
 
#ifdef __cplusplus
extern "C" {
#endif

enum dmic_state {
        DMIC_STATE_UNINIT,      
        DMIC_STATE_INITIALIZED, 
        DMIC_STATE_CONFIGURED,  
        DMIC_STATE_ACTIVE,      
        DMIC_STATE_PAUSED,      
        DMIC_STATE_ERROR,       
};

enum dmic_trigger {
        DMIC_TRIGGER_STOP,      
        DMIC_TRIGGER_START,     
        DMIC_TRIGGER_PAUSE,     
        DMIC_TRIGGER_RELEASE,   
        DMIC_TRIGGER_RESET,     
};

enum pdm_lr {
        PDM_CHAN_LEFT,  
        PDM_CHAN_RIGHT, 
};

struct pdm_io_cfg {
        uint32_t min_pdm_clk_freq;
        uint32_t max_pdm_clk_freq;
        uint8_t min_pdm_clk_dc;
        uint8_t max_pdm_clk_dc;

        uint8_t pdm_clk_pol;
        uint8_t pdm_data_pol;
        uint32_t pdm_clk_skew;
};

#define PDM_DT_IO_CFG_GET(node_id)                                              \
        {                                                                       \
                .min_pdm_clk_freq = DT_PROP(node_id, clk_frequency_min),        \
                .max_pdm_clk_freq = DT_PROP(node_id, clk_frequency_max),        \
                .min_pdm_clk_dc = DT_PROP(node_id, clk_duty_cycle_min),         \
                .max_pdm_clk_dc = DT_PROP(node_id, clk_duty_cycle_max),         \
        }

#define PDM_DT_HAS_LEFT_CHANNEL(node_id)        DT_PROP(node_id, channel_left)

#define PDM_DT_HAS_RIGHT_CHANNEL(node_id)       DT_PROP(node_id, channel_right)

struct pcm_stream_cfg {
        uint32_t pcm_rate;
        uint8_t pcm_width;
        uint16_t block_size;
        int8_t gain_db;
        struct k_mem_slab *mem_slab;
};

struct pdm_chan_cfg {
        uint32_t req_chan_map_lo;       
        uint32_t req_chan_map_hi;       

        uint32_t act_chan_map_lo;       
        uint32_t act_chan_map_hi;       

        uint8_t req_num_chan;
        uint8_t act_num_chan;
        uint8_t req_num_streams;
        uint8_t act_num_streams;
};

struct dmic_cfg {
        struct pdm_io_cfg io;
        struct pcm_stream_cfg *streams;
        struct pdm_chan_cfg channel;
};


typedef int (*dmic_configure_t)(const struct device *dev, struct dmic_cfg *config);

typedef int (*dmic_trigger_t)(const struct device *dev, enum dmic_trigger cmd);

typedef int (*dmic_read_t)(const struct device *dev, uint8_t stream, void **buffer,
                           size_t *size, int32_t timeout);

#define _dmic_ops dmic_driver_api __DEPRECATED_MACRO

__subsystem struct dmic_driver_api {
        dmic_configure_t configure;
        dmic_trigger_t trigger;
        dmic_read_t read;
};


static inline uint32_t dmic_build_channel_map(uint8_t channel, uint8_t pdm,
                enum pdm_lr lr)
{
        return ((((pdm & BIT_MASK(3)) << 1) | lr) <<
                        ((channel & BIT_MASK(3)) * 4U));
}

static inline void dmic_parse_channel_map(uint32_t channel_map_lo,
                uint32_t channel_map_hi, uint8_t channel, uint8_t *pdm, enum pdm_lr *lr)
{
        uint32_t channel_map;
 
        channel_map = (channel < 8) ? channel_map_lo : channel_map_hi;
        channel_map >>= ((channel & BIT_MASK(3)) * 4U);
 
        *pdm = (channel_map >> 1) & BIT_MASK(3);
        *lr = (enum pdm_lr) (channel_map & BIT(0));
}

static inline uint32_t dmic_build_clk_skew_map(uint8_t pdm, uint8_t skew)
{
        return ((skew & BIT_MASK(4)) << ((pdm & BIT_MASK(3)) * 4U));
}

static inline int dmic_configure(const struct device *dev,
                                 struct dmic_cfg *cfg)
{
        return DEVICE_API_GET(dmic, dev)->configure(dev, cfg);
}

static inline int dmic_trigger(const struct device *dev,
                               enum dmic_trigger cmd)
{
        return DEVICE_API_GET(dmic, dev)->trigger(dev, cmd);
}

static inline int dmic_read(const struct device *dev, uint8_t stream,
                            void **buffer,
                            size_t *size, int32_t timeout)
{
        return DEVICE_API_GET(dmic, dev)->read(dev, stream, buffer, size, timeout);
}
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_AUDIO_DMIC_H_ */