ASoC: mediatek: implement mediatek common structure (283b6124) · Commits · e / devices / android_kernel_xiaomi_nabu

sound/soc/mediatek/common/mtk-afe-fe-dai.c

0 → 100644

+379 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* mtk-afe-fe-dais.c -- Mediatek afe fe dai operator
			*
			* Copyright (c) 2016 MediaTek Inc.
			* Author: Garlic Tseng <garlic.tseng@mediatek.com>
			*
			* This program is free software; you can redistribute it and/or modify
			* it under the terms of the GNU General Public License version 2 and
			* only version 2 as published by the Free Software Foundation.
			*
			* This program is distributed in the hope that it will be useful,
			* but WITHOUT ANY WARRANTY; without even the implied warranty of
			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			* GNU General Public License for more details.
			*/

			#include <linux/module.h>
			#include <linux/pm_runtime.h>
			#include <linux/regmap.h>
			#include <sound/soc.h>
			#include "mtk-afe-fe-dai.h"
			#include "mtk-base-afe.h"

			#define AFE_BASE_END_OFFSET 8

			int mtk_regmap_update_bits(struct regmap *map, int reg, unsigned int mask,
			unsigned int val)
			{
			if (reg < 0)
			return 0;
			return regmap_update_bits(map, reg, mask, val);
			}

			int mtk_regmap_write(struct regmap *map, int reg, unsigned int val)
			{
			if (reg < 0)
			return 0;
			return regmap_write(map, reg, val);
			}

			int mtk_afe_fe_startup(struct snd_pcm_substream *substream,
			struct snd_soc_dai *dai)
			{
			struct snd_soc_pcm_runtime *rtd = substream->private_data;
			struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);
			struct snd_pcm_runtime *runtime = substream->runtime;
			int memif_num = rtd->cpu_dai->id;
			struct mtk_base_afe_memif *memif = &afe->memif[memif_num];
			const struct snd_pcm_hardware *mtk_afe_hardware = afe->mtk_afe_hardware;
			int ret;

			memif->substream = substream;

			snd_pcm_hw_constraint_step(substream->runtime, 0,
			SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 16);
			/* enable agent */
			mtk_regmap_update_bits(afe->regmap, memif->data->agent_disable_reg,
			1 << memif->data->agent_disable_shift,
			0 << memif->data->agent_disable_shift);

			snd_soc_set_runtime_hwparams(substream, mtk_afe_hardware);

			/*
			* Capture cannot use ping-pong buffer since hw_ptr at IRQ may be
			* smaller than period_size due to AFE's internal buffer.
			* This easily leads to overrun when avail_min is period_size.
			* One more period can hold the possible unread buffer.
			*/
			if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
			int periods_max = mtk_afe_hardware->periods_max;

			ret = snd_pcm_hw_constraint_minmax(runtime,
			SNDRV_PCM_HW_PARAM_PERIODS,
			3, periods_max);
			if (ret < 0) {
			dev_err(afe->dev, "hw_constraint_minmax failed\n");
			return ret;
			}
			}

			ret = snd_pcm_hw_constraint_integer(runtime,
			SNDRV_PCM_HW_PARAM_PERIODS);
			if (ret < 0)
			dev_err(afe->dev, "snd_pcm_hw_constraint_integer failed\n");

			/* dynamic allocate irq to memif */
			if (memif->irq_usage < 0) {
			int irq_id = mtk_dynamic_irq_acquire(afe);

			if (irq_id != afe->irqs_size) {
			/* link */
			memif->irq_usage = irq_id;
			} else {
			dev_err(afe->dev, "%s() error: no more asys irq\n",
			__func__);
			ret = -EBUSY;
			}
			}
			return ret;
			}
			EXPORT_SYMBOL_GPL(mtk_afe_fe_startup);

			void mtk_afe_fe_shutdown(struct snd_pcm_substream *substream,
			struct snd_soc_dai *dai)
			{
			struct snd_soc_pcm_runtime *rtd = substream->private_data;
			struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);
			struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
			int irq_id;

			irq_id = memif->irq_usage;

			mtk_regmap_update_bits(afe->regmap, memif->data->agent_disable_reg,
			1 << memif->data->agent_disable_shift,
			1 << memif->data->agent_disable_shift);

			if (!memif->const_irq) {
			mtk_dynamic_irq_release(afe, irq_id);
			memif->irq_usage = -1;
			memif->substream = NULL;
			}
			}
			EXPORT_SYMBOL_GPL(mtk_afe_fe_shutdown);

			int mtk_afe_fe_hw_params(struct snd_pcm_substream *substream,
			struct snd_pcm_hw_params *params,
			struct snd_soc_dai *dai)
			{
			struct snd_soc_pcm_runtime *rtd = substream->private_data;
			struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);
			struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
			int msb_at_bit33 = 0;
			int ret, fs = 0;

			ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
			if (ret < 0)
			return ret;

			msb_at_bit33 = upper_32_bits(substream->runtime->dma_addr) ? 1 : 0;
			memif->phys_buf_addr = lower_32_bits(substream->runtime->dma_addr);
			memif->buffer_size = substream->runtime->dma_bytes;

			/* start */
			mtk_regmap_write(afe->regmap, memif->data->reg_ofs_base,
			memif->phys_buf_addr);
			/* end */
			mtk_regmap_write(afe->regmap,
			memif->data->reg_ofs_base + AFE_BASE_END_OFFSET,
			memif->phys_buf_addr + memif->buffer_size - 1);

			/* set MSB to 33-bit */
			mtk_regmap_update_bits(afe->regmap, memif->data->msb_reg,
			1 << memif->data->msb_shift,
			msb_at_bit33 << memif->data->msb_shift);

			/* set channel */
			if (memif->data->mono_shift >= 0) {
			unsigned int mono = (params_channels(params) == 1) ? 1 : 0;

			mtk_regmap_update_bits(afe->regmap, memif->data->mono_reg,
			1 << memif->data->mono_shift,
			mono << memif->data->mono_shift);
			}

			/* set rate */
			if (memif->data->fs_shift < 0)
			return 0;

			fs = afe->memif_fs(substream, params_rate(params));

			if (fs < 0)
			return -EINVAL;

			mtk_regmap_update_bits(afe->regmap, memif->data->fs_reg,
			memif->data->fs_maskbit << memif->data->fs_shift,
			fs << memif->data->fs_shift);

			return 0;
			}
			EXPORT_SYMBOL_GPL(mtk_afe_fe_hw_params);

			int mtk_afe_fe_hw_free(struct snd_pcm_substream *substream,
			struct snd_soc_dai *dai)
			{
			return snd_pcm_lib_free_pages(substream);
			}
			EXPORT_SYMBOL_GPL(mtk_afe_fe_hw_free);

			int mtk_afe_fe_trigger(struct snd_pcm_substream *substream, int cmd,
			struct snd_soc_dai *dai)
			{
			struct snd_soc_pcm_runtime *rtd = substream->private_data;
			struct snd_pcm_runtime * const runtime = substream->runtime;
			struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);
			struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
			struct mtk_base_afe_irq *irqs = &afe->irqs[memif->irq_usage];
			const struct mtk_base_irq_data *irq_data = irqs->irq_data;
			unsigned int counter = runtime->period_size;
			int fs;

			dev_dbg(afe->dev, "%s %s cmd=%d\n", __func__, memif->data->name, cmd);

			switch (cmd) {
			case SNDRV_PCM_TRIGGER_START:
			case SNDRV_PCM_TRIGGER_RESUME:
			if (memif->data->enable_shift >= 0)
			mtk_regmap_update_bits(afe->regmap,
			memif->data->enable_reg,
			1 << memif->data->enable_shift,
			1 << memif->data->enable_shift);

			/* set irq counter */
			mtk_regmap_update_bits(afe->regmap, irq_data->irq_cnt_reg,
			irq_data->irq_cnt_maskbit
			<< irq_data->irq_cnt_shift,
			counter << irq_data->irq_cnt_shift);

			/* set irq fs */
			fs = afe->irq_fs(substream, runtime->rate);

			if (fs < 0)
			return -EINVAL;

			mtk_regmap_update_bits(afe->regmap, irq_data->irq_fs_reg,
			irq_data->irq_fs_maskbit
			<< irq_data->irq_fs_shift,
			fs << irq_data->irq_fs_shift);

			/* enable interrupt */
			mtk_regmap_update_bits(afe->regmap, irq_data->irq_en_reg,
			1 << irq_data->irq_en_shift,
			1 << irq_data->irq_en_shift);

			return 0;
			case SNDRV_PCM_TRIGGER_STOP:
			case SNDRV_PCM_TRIGGER_SUSPEND:
			mtk_regmap_update_bits(afe->regmap, memif->data->enable_reg,
			1 << memif->data->enable_shift, 0);
			/* disable interrupt */
			mtk_regmap_update_bits(afe->regmap, irq_data->irq_en_reg,
			1 << irq_data->irq_en_shift,
			0 << irq_data->irq_en_shift);
			/* and clear pending IRQ */
			mtk_regmap_write(afe->regmap, irq_data->irq_clr_reg,
			1 << irq_data->irq_clr_shift);
			return 0;
			default:
			return -EINVAL;
			}
			}
			EXPORT_SYMBOL_GPL(mtk_afe_fe_trigger);

			int mtk_afe_fe_prepare(struct snd_pcm_substream *substream,
			struct snd_soc_dai *dai)
			{
			struct snd_soc_pcm_runtime *rtd = substream->private_data;
			struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);
			struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
			int hd_audio = 0;

			/* set hd mode */
			switch (substream->runtime->format) {
			case SNDRV_PCM_FORMAT_S16_LE:
			hd_audio = 0;
			break;
			case SNDRV_PCM_FORMAT_S32_LE:
			hd_audio = 1;
			break;
			case SNDRV_PCM_FORMAT_S24_LE:
			hd_audio = 1;
			break;
			default:
			dev_err(afe->dev, "%s() error: unsupported format %d\n",
			__func__, substream->runtime->format);
			break;
			}

			mtk_regmap_update_bits(afe->regmap, memif->data->hd_reg,
			1 << memif->data->hd_shift,
			hd_audio << memif->data->hd_shift);

			return 0;
			}
			EXPORT_SYMBOL_GPL(mtk_afe_fe_prepare);

			const struct snd_soc_dai_ops mtk_afe_fe_ops = {
			.startup = mtk_afe_fe_startup,
			.shutdown = mtk_afe_fe_shutdown,
			.hw_params = mtk_afe_fe_hw_params,
			.hw_free = mtk_afe_fe_hw_free,
			.prepare = mtk_afe_fe_prepare,
			.trigger = mtk_afe_fe_trigger,
			};
			EXPORT_SYMBOL_GPL(mtk_afe_fe_ops);

			static DEFINE_MUTEX(irqs_lock);
			int mtk_dynamic_irq_acquire(struct mtk_base_afe *afe)
			{
			int i;

			mutex_lock(&afe->irq_alloc_lock);
			for (i = 0; i < afe->irqs_size; ++i) {
			if (afe->irqs[i].irq_occupyed == 0) {
			afe->irqs[i].irq_occupyed = 1;
			mutex_unlock(&afe->irq_alloc_lock);
			return i;
			}
			}
			mutex_unlock(&afe->irq_alloc_lock);
			return afe->irqs_size;
			}
			EXPORT_SYMBOL_GPL(mtk_dynamic_irq_acquire);

			int mtk_dynamic_irq_release(struct mtk_base_afe *afe, int irq_id)
			{
			mutex_lock(&afe->irq_alloc_lock);
			if (irq_id >= 0 && irq_id < afe->irqs_size) {
			afe->irqs[irq_id].irq_occupyed = 0;
			mutex_unlock(&afe->irq_alloc_lock);
			return 0;
			}
			mutex_unlock(&afe->irq_alloc_lock);
			return -EINVAL;
			}
			EXPORT_SYMBOL_GPL(mtk_dynamic_irq_release);

			int mtk_afe_dai_suspend(struct snd_soc_dai *dai)
			{
			struct mtk_base_afe *afe = dev_get_drvdata(dai->dev);
			struct device *dev = afe->dev;
			struct regmap *regmap = afe->regmap;
			int i;

			if (pm_runtime_status_suspended(dev) \|\| afe->suspended)
			return 0;

			if (!afe->reg_back_up)
			afe->reg_back_up =
			devm_kcalloc(dev, afe->reg_back_up_list_num,
			sizeof(unsigned int), GFP_KERNEL);

			for (i = 0; i < afe->reg_back_up_list_num; i++)
			regmap_read(regmap, afe->reg_back_up_list[i],
			&afe->reg_back_up[i]);

			afe->suspended = true;
			afe->runtime_suspend(dev);
			return 0;
			}
			EXPORT_SYMBOL_GPL(mtk_afe_dai_suspend);

			int mtk_afe_dai_resume(struct snd_soc_dai *dai)
			{
			struct mtk_base_afe *afe = dev_get_drvdata(dai->dev);
			struct device *dev = afe->dev;
			struct regmap *regmap = afe->regmap;
			int i = 0;

			if (pm_runtime_status_suspended(dev) \|\| !afe->suspended)
			return 0;

			afe->runtime_resume(dev);

			if (!afe->reg_back_up)
			dev_dbg(dev, "%s no reg_backup\n", __func__);

			for (i = 0; i < afe->reg_back_up_list_num; i++)
			mtk_regmap_write(regmap, afe->reg_back_up_list[i],
			afe->reg_back_up[i]);

			afe->suspended = false;
			return 0;
			}
			EXPORT_SYMBOL_GPL(mtk_afe_dai_resume);

			MODULE_DESCRIPTION("Mediatek simple fe dai operator");
			MODULE_AUTHOR("Garlic Tseng <garlic.tseng@mediatek.com>");
			MODULE_LICENSE("GPL v2");

sound/soc/mediatek/common/mtk-afe-fe-dai.h

0 → 100644

+45 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* mtk-afe-fe-dais.h -- Mediatek afe fe dai operator definition
			*
			* Copyright (c) 2016 MediaTek Inc.
			* Author: Garlic Tseng <garlic.tseng@mediatek.com>
			*
			* This program is free software; you can redistribute it and/or modify
			* it under the terms of the GNU General Public License version 2 and
			* only version 2 as published by the Free Software Foundation.
			*
			* This program is distributed in the hope that it will be useful,
			* but WITHOUT ANY WARRANTY; without even the implied warranty of
			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			* GNU General Public License for more details.
			*/

			#ifndef _MTK_AFE_FE_DAI_H_
			#define _MTK_AFE_FE_DAI_H_

			struct snd_soc_dai_ops;
			struct mtk_base_afe;
			struct mtk_base_afe_memif;

			int mtk_afe_fe_startup(struct snd_pcm_substream *substream,
			struct snd_soc_dai *dai);
			void mtk_afe_fe_shutdown(struct snd_pcm_substream *substream,
			struct snd_soc_dai *dai);
			int mtk_afe_fe_hw_params(struct snd_pcm_substream *substream,
			struct snd_pcm_hw_params *params,
			struct snd_soc_dai *dai);
			int mtk_afe_fe_hw_free(struct snd_pcm_substream *substream,
			struct snd_soc_dai *dai);
			int mtk_afe_fe_prepare(struct snd_pcm_substream *substream,
			struct snd_soc_dai *dai);
			int mtk_afe_fe_trigger(struct snd_pcm_substream *substream, int cmd,
			struct snd_soc_dai *dai);

			extern const struct snd_soc_dai_ops mtk_afe_fe_ops;

			int mtk_dynamic_irq_acquire(struct mtk_base_afe *afe);
			int mtk_dynamic_irq_release(struct mtk_base_afe *afe, int irq_id);
			int mtk_afe_dai_suspend(struct snd_soc_dai *dai);
			int mtk_afe_dai_resume(struct snd_soc_dai *dai);

			#endif

sound/soc/mediatek/common/mtk-afe-platform-driver.c

0 → 100644

+90 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* mtk-afe-platform-driver.c -- Mediatek afe platform driver
			*
			* Copyright (c) 2016 MediaTek Inc.
			* Author: Garlic Tseng <garlic.tseng@mediatek.com>
			*
			* This program is free software; you can redistribute it and/or modify
			* it under the terms of the GNU General Public License version 2 and
			* only version 2 as published by the Free Software Foundation.
			*
			* This program is distributed in the hope that it will be useful,
			* but WITHOUT ANY WARRANTY; without even the implied warranty of
			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			* GNU General Public License for more details.
			*/

			#include <linux/module.h>
			#include <linux/dma-mapping.h>
			#include <sound/soc.h>

			#include "mtk-afe-platform-driver.h"
			#include "mtk-base-afe.h"

			static snd_pcm_uframes_t mtk_afe_pcm_pointer
			(struct snd_pcm_substream *substream)
			{
			struct snd_soc_pcm_runtime *rtd = substream->private_data;
			struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);
			struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
			const struct mtk_base_memif_data *memif_data = memif->data;
			struct regmap *regmap = afe->regmap;
			struct device *dev = afe->dev;
			int reg_ofs_base = memif_data->reg_ofs_base;
			int reg_ofs_cur = memif_data->reg_ofs_cur;
			unsigned int hw_ptr = 0, hw_base = 0;
			int ret, pcm_ptr_bytes;

			ret = regmap_read(regmap, reg_ofs_cur, &hw_ptr);
			if (ret \|\| hw_ptr == 0) {
			dev_err(dev, "%s hw_ptr err\n", __func__);
			pcm_ptr_bytes = 0;
			goto POINTER_RETURN_FRAMES;
			}

			ret = regmap_read(regmap, reg_ofs_base, &hw_base);
			if (ret \|\| hw_base == 0) {
			dev_err(dev, "%s hw_ptr err\n", __func__);
			pcm_ptr_bytes = 0;
			goto POINTER_RETURN_FRAMES;
			}

			pcm_ptr_bytes = hw_ptr - hw_base;

			POINTER_RETURN_FRAMES:
			return bytes_to_frames(substream->runtime, pcm_ptr_bytes);
			}

			static const struct snd_pcm_ops mtk_afe_pcm_ops = {
			.ioctl = snd_pcm_lib_ioctl,
			.pointer = mtk_afe_pcm_pointer,
			};

			static int mtk_afe_pcm_new(struct snd_soc_pcm_runtime *rtd)
			{
			size_t size;
			struct snd_card *card = rtd->card->snd_card;
			struct snd_pcm *pcm = rtd->pcm;
			struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);

			size = afe->mtk_afe_hardware->buffer_bytes_max;
			return snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
			card->dev, size, size);
			}

			static void mtk_afe_pcm_free(struct snd_pcm *pcm)
			{
			snd_pcm_lib_preallocate_free_for_all(pcm);
			}

			const struct snd_soc_platform_driver mtk_afe_pcm_platform = {
			.ops = &mtk_afe_pcm_ops,
			.pcm_new = mtk_afe_pcm_new,
			.pcm_free = mtk_afe_pcm_free,
			};
			EXPORT_SYMBOL_GPL(mtk_afe_pcm_platform);

			MODULE_DESCRIPTION("Mediatek simple platform driver");
			MODULE_AUTHOR("Garlic Tseng <garlic.tseng@mediatek.com>");
			MODULE_LICENSE("GPL v2");

sound/soc/mediatek/common/mtk-afe-platform-driver.h

0 → 100644

+23 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* mtk-afe-platform-driver.h -- Mediatek afe platform driver definition
			*
			* Copyright (c) 2016 MediaTek Inc.
			* Author: Garlic Tseng <garlic.tseng@mediatek.com>
			*
			* This program is free software; you can redistribute it and/or modify
			* it under the terms of the GNU General Public License version 2 and
			* only version 2 as published by the Free Software Foundation.
			*
			* This program is distributed in the hope that it will be useful,
			* but WITHOUT ANY WARRANTY; without even the implied warranty of
			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			* GNU General Public License for more details.
			*/

			#ifndef _MTK_AFE_PLATFORM_DRIVER_H_
			#define _MTK_AFE_PLATFORM_DRIVER_H_

			extern const struct snd_soc_platform_driver mtk_afe_pcm_platform;

			#endif

sound/soc/mediatek/common/mtk-base-afe.h

0 → 100644

+104 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* mtk-base-afe.h -- Mediatek base afe structure
			*
			* Copyright (c) 2016 MediaTek Inc.
			* Author: Garlic Tseng <garlic.tseng@mediatek.com>
			*
			* This program is free software; you can redistribute it and/or modify
			* it under the terms of the GNU General Public License version 2 and
			* only version 2 as published by the Free Software Foundation.
			*
			* This program is distributed in the hope that it will be useful,
			* but WITHOUT ANY WARRANTY; without even the implied warranty of
			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			* GNU General Public License for more details.
			*/

			#ifndef _MTK_BASE_AFE_H_
			#define _MTK_BASE_AFE_H_

			struct mtk_base_memif_data {
			int id;
			const char *name;
			int reg_ofs_base;
			int reg_ofs_cur;
			int fs_reg;
			int fs_shift;
			int fs_maskbit;
			int mono_reg;
			int mono_shift;
			int enable_reg;
			int enable_shift;
			int hd_reg;
			int hd_shift;
			int msb_reg;
			int msb_shift;
			int agent_disable_reg;
			int agent_disable_shift;
			};

			struct mtk_base_irq_data {
			int id;
			int irq_cnt_reg;
			int irq_cnt_shift;
			int irq_cnt_maskbit;
			int irq_fs_reg;
			int irq_fs_shift;
			int irq_fs_maskbit;
			int irq_en_reg;
			int irq_en_shift;
			int irq_clr_reg;
			int irq_clr_shift;
			};

			struct device;
			struct mtk_base_afe_memif;
			struct mtk_base_afe_irq;
			struct regmap;
			struct snd_pcm_substream;
			struct snd_soc_dai;

			struct mtk_base_afe {
			void __iomem *base_addr;
			struct device *dev;
			struct regmap *regmap;
			struct mutex irq_alloc_lock; /* dynamic alloc irq lock */

			unsigned int const *reg_back_up_list;
			unsigned int *reg_back_up;
			unsigned int reg_back_up_list_num;

			int (runtime_suspend)(struct device dev);
			int (runtime_resume)(struct device dev);
			bool suspended;

			struct mtk_base_afe_memif *memif;
			int memif_size;
			struct mtk_base_afe_irq *irqs;
			int irqs_size;

			const struct snd_pcm_hardware *mtk_afe_hardware;
			int (memif_fs)(struct snd_pcm_substream substream,
			unsigned int rate);
			int (irq_fs)(struct snd_pcm_substream substream,
			unsigned int rate);

			void *platform_priv;
			};

			struct mtk_base_afe_memif {
			unsigned int phys_buf_addr;
			int buffer_size;
			struct snd_pcm_substream *substream;
			const struct mtk_base_memif_data *data;
			int irq_usage;
			int const_irq;
			};

			struct mtk_base_afe_irq {
			const struct mtk_base_irq_data *irq_data;
			int irq_occupyed;
			};

			#endif