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>
 
#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;
};
 
struct pcm_stream_cfg {
        uint32_t                        pcm_rate;
        uint8_t                 pcm_width;
        uint16_t                        block_size;
        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;
};
 
struct _dmic_ops {
        int (*configure)(const struct device *dev, struct dmic_cfg *config);
        int (*trigger)(const struct device *dev, enum dmic_trigger cmd);
        int (*read)(const struct device *dev, uint8_t stream, void **buffer,
                        size_t *size, int32_t timeout);
};
 
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)
{
        const struct _dmic_ops *api =
                (const struct _dmic_ops *)dev->api;
 
        return api->configure(dev, cfg);
}
 
static inline int dmic_trigger(const struct device *dev,
                               enum dmic_trigger cmd)
{
        const struct _dmic_ops *api =
                (const struct _dmic_ops *)dev->api;
 
        return api->trigger(dev, cmd);
}
 
static inline int dmic_read(const struct device *dev, uint8_t stream,
                            void **buffer,
                            size_t *size, int32_t timeout)
{
        const struct _dmic_ops *api =
                (const struct _dmic_ops *)dev->api;
 
        return api->read(dev, stream, buffer, size, timeout);
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_AUDIO_DMIC_H_ */