Unverified Commit b748ad38 authored by Mark Brown's avatar Mark Brown
Browse files

Merge series "ASoC: SOF: Intel: split Baytrail and Merrifield" from... 

Merge series "ASoC: SOF: Intel: split Baytrail and Merrifield" from Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>:

We've had recurring randconfig issues with the two platforms relying
on ACPI and PCI. I think it's time to split the two and introduce a
common 'atom' module, so that dependencies are better handled.

I chose not to add a Fixes tag since the changes are rather invasive,
and the randconfig issues only happen in non-functional cases.

There should be no functional changes with this patchset, only code
moved and renamed.

Pierre-Louis Bossart (2):
  ASoC: SOF: Intel: byt: prepare split between Baytrail and Merrifield
  ASoC: SOF: Intel: move common ATOM stuff to module

 sound/soc/sof/intel/Makefile  |   5 +-
 sound/soc/sof/intel/atom.c    | 463 ++++++++++++++++++++
 sound/soc/sof/intel/atom.h    |  74 ++++
 sound/soc/sof/intel/byt.c     | 768 ++++------------------------------
 sound/soc/sof/intel/pci-tng.c | 171 +++++++-
 5 files changed, 783 insertions(+), 698 deletions(-)
 create mode 100644 sound/soc/sof/intel/atom.c
 create mode 100644 sound/soc/sof/intel/atom.h

--
2.25.1
parents 93c964af 47fad239

sound/soc/sof/intel/Makefile

+4 −1
Original line number Diff line number Diff line
@@ -13,7 +13,10 @@ snd-sof-intel-hda-common-$(CONFIG_SND_SOC_SOF_HDA_PROBES) += hda-compress.o 


snd-sof-intel-hda-objs := hda-codec.o



obj-$(CONFIG_SND_SOC_SOF_INTEL_ATOM_HIFI_EP) += snd-sof-acpi-intel-byt.o

snd-sof-intel-atom-objs := atom.o



obj-$(CONFIG_SND_SOC_SOF_INTEL_ATOM_HIFI_EP) += snd-sof-intel-atom.o

obj-$(CONFIG_SND_SOC_SOF_BAYTRAIL) += snd-sof-acpi-intel-byt.o

obj-$(CONFIG_SND_SOC_SOF_BROADWELL) += snd-sof-acpi-intel-bdw.o

obj-$(CONFIG_SND_SOC_SOF_INTEL_HIFI_EP_IPC) += snd-sof-intel-ipc.o

obj-$(CONFIG_SND_SOC_SOF_HDA_COMMON) += snd-sof-intel-hda-common.o

sound/soc/sof/intel/atom.c

0 → 100644
+463 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)

//

// This file is provided under a dual BSD/GPLv2 license.  When using or

// redistributing this file, you may do so under either license.

//

// Copyright(c) 2018-2021 Intel Corporation. All rights reserved.

//

// Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>

//



/*

 * Hardware interface for audio DSP on Atom devices

 */



#include <linux/module.h>

#include <sound/sof.h>

#include <sound/sof/xtensa.h>

#include <sound/soc-acpi.h>

#include <sound/soc-acpi-intel-match.h>

#include <sound/intel-dsp-config.h>

#include "../ops.h"

#include "shim.h"

#include "atom.h"

#include "../sof-acpi-dev.h"

#include "../sof-audio.h"

#include "../../intel/common/soc-intel-quirks.h"



static void atom_host_done(struct snd_sof_dev *sdev);

static void atom_dsp_done(struct snd_sof_dev *sdev);

static void atom_get_reply(struct snd_sof_dev *sdev);



/*

 * Debug

 */



static void atom_get_registers(struct snd_sof_dev *sdev,

			       struct sof_ipc_dsp_oops_xtensa *xoops,

			       struct sof_ipc_panic_info *panic_info,

			       u32 *stack, size_t stack_words)

{

	u32 offset = sdev->dsp_oops_offset;



	/* first read regsisters */

	sof_mailbox_read(sdev, offset, xoops, sizeof(*xoops));



	/* note: variable AR register array is not read */



	/* then get panic info */

	if (xoops->arch_hdr.totalsize > EXCEPT_MAX_HDR_SIZE) {

		dev_err(sdev->dev, "invalid header size 0x%x. FW oops is bogus\n",

			xoops->arch_hdr.totalsize);

		return;

	}

	offset += xoops->arch_hdr.totalsize;

	sof_mailbox_read(sdev, offset, panic_info, sizeof(*panic_info));



	/* then get the stack */

	offset += sizeof(*panic_info);

	sof_mailbox_read(sdev, offset, stack, stack_words * sizeof(u32));

}



void atom_dump(struct snd_sof_dev *sdev, u32 flags)

{

	struct sof_ipc_dsp_oops_xtensa xoops;

	struct sof_ipc_panic_info panic_info;

	u32 stack[STACK_DUMP_SIZE];

	u64 status, panic, imrd, imrx;



	/* now try generic SOF status messages */

	status = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IPCD);

	panic = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IPCX);

	atom_get_registers(sdev, &xoops, &panic_info, stack,

			   STACK_DUMP_SIZE);

	snd_sof_get_status(sdev, status, panic, &xoops, &panic_info, stack,

			   STACK_DUMP_SIZE);



	/* provide some context for firmware debug */

	imrx = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IMRX);

	imrd = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IMRD);

	dev_err(sdev->dev,

		"error: ipc host -> DSP: pending %s complete %s raw 0x%llx\n",

		(panic & SHIM_IPCX_BUSY) ? "yes" : "no",

		(panic & SHIM_IPCX_DONE) ? "yes" : "no", panic);

	dev_err(sdev->dev,

		"error: mask host: pending %s complete %s raw 0x%llx\n",

		(imrx & SHIM_IMRX_BUSY) ? "yes" : "no",

		(imrx & SHIM_IMRX_DONE) ? "yes" : "no", imrx);

	dev_err(sdev->dev,

		"error: ipc DSP -> host: pending %s complete %s raw 0x%llx\n",

		(status & SHIM_IPCD_BUSY) ? "yes" : "no",

		(status & SHIM_IPCD_DONE) ? "yes" : "no", status);

	dev_err(sdev->dev,

		"error: mask DSP: pending %s complete %s raw 0x%llx\n",

		(imrd & SHIM_IMRD_BUSY) ? "yes" : "no",

		(imrd & SHIM_IMRD_DONE) ? "yes" : "no", imrd);



}

EXPORT_SYMBOL_NS(atom_dump, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);



/*

 * IPC Doorbell IRQ handler and thread.

 */



irqreturn_t atom_irq_handler(int irq, void *context)

{

	struct snd_sof_dev *sdev = context;

	u64 ipcx, ipcd;

	int ret = IRQ_NONE;



	ipcx = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IPCX);

	ipcd = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IPCD);



	if (ipcx & SHIM_BYT_IPCX_DONE) {



		/* reply message from DSP, Mask Done interrupt first */

		snd_sof_dsp_update_bits64_unlocked(sdev, DSP_BAR,

						   SHIM_IMRX,

						   SHIM_IMRX_DONE,

						   SHIM_IMRX_DONE);

		ret = IRQ_WAKE_THREAD;

	}



	if (ipcd & SHIM_BYT_IPCD_BUSY) {



		/* new message from DSP, Mask Busy interrupt first */

		snd_sof_dsp_update_bits64_unlocked(sdev, DSP_BAR,

						   SHIM_IMRX,

						   SHIM_IMRX_BUSY,

						   SHIM_IMRX_BUSY);

		ret = IRQ_WAKE_THREAD;

	}



	return ret;

}

EXPORT_SYMBOL_NS(atom_irq_handler, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);



irqreturn_t atom_irq_thread(int irq, void *context)

{

	struct snd_sof_dev *sdev = context;

	u64 ipcx, ipcd;



	ipcx = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IPCX);

	ipcd = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IPCD);



	/* reply message from DSP */

	if (ipcx & SHIM_BYT_IPCX_DONE) {



		spin_lock_irq(&sdev->ipc_lock);



		/*

		 * handle immediate reply from DSP core. If the msg is

		 * found, set done bit in cmd_done which is called at the

		 * end of message processing function, else set it here

		 * because the done bit can't be set in cmd_done function

		 * which is triggered by msg

		 */

		atom_get_reply(sdev);

		snd_sof_ipc_reply(sdev, ipcx);



		atom_dsp_done(sdev);



		spin_unlock_irq(&sdev->ipc_lock);

	}



	/* new message from DSP */

	if (ipcd & SHIM_BYT_IPCD_BUSY) {



		/* Handle messages from DSP Core */

		if ((ipcd & SOF_IPC_PANIC_MAGIC_MASK) == SOF_IPC_PANIC_MAGIC) {

			snd_sof_dsp_panic(sdev, PANIC_OFFSET(ipcd) +

					  MBOX_OFFSET);

		} else {

			snd_sof_ipc_msgs_rx(sdev);

		}



		atom_host_done(sdev);

	}



	return IRQ_HANDLED;

}

EXPORT_SYMBOL_NS(atom_irq_thread, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);



int atom_send_msg(struct snd_sof_dev *sdev, struct snd_sof_ipc_msg *msg)

{

	/* unmask and prepare to receive Done interrupt */

	snd_sof_dsp_update_bits64_unlocked(sdev, DSP_BAR, SHIM_IMRX,

					   SHIM_IMRX_DONE, 0);



	/* send the message */

	sof_mailbox_write(sdev, sdev->host_box.offset, msg->msg_data,

			  msg->msg_size);

	snd_sof_dsp_write64(sdev, DSP_BAR, SHIM_IPCX, SHIM_BYT_IPCX_BUSY);



	return 0;

}

EXPORT_SYMBOL_NS(atom_send_msg, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);



static void atom_get_reply(struct snd_sof_dev *sdev)

{

	struct snd_sof_ipc_msg *msg = sdev->msg;

	struct sof_ipc_reply reply;

	int ret = 0;



	/*

	 * Sometimes, there is unexpected reply ipc arriving. The reply

	 * ipc belongs to none of the ipcs sent from driver.

	 * In this case, the driver must ignore the ipc.

	 */

	if (!msg) {

		dev_warn(sdev->dev, "unexpected ipc interrupt raised!\n");

		return;

	}



	/* get reply */

	sof_mailbox_read(sdev, sdev->host_box.offset, &reply, sizeof(reply));



	if (reply.error < 0) {

		memcpy(msg->reply_data, &reply, sizeof(reply));

		ret = reply.error;

	} else {

		/* reply correct size ? */

		if (reply.hdr.size != msg->reply_size) {

			dev_err(sdev->dev, "error: reply expected %zu got %u bytes\n",

				msg->reply_size, reply.hdr.size);

			ret = -EINVAL;

		}



		/* read the message */

		if (msg->reply_size > 0)

			sof_mailbox_read(sdev, sdev->host_box.offset,

					 msg->reply_data, msg->reply_size);

	}



	msg->reply_error = ret;

}



int atom_get_mailbox_offset(struct snd_sof_dev *sdev)

{

	return MBOX_OFFSET;

}

EXPORT_SYMBOL_NS(atom_get_mailbox_offset, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);



int atom_get_window_offset(struct snd_sof_dev *sdev, u32 id)

{

	return MBOX_OFFSET;

}

EXPORT_SYMBOL_NS(atom_get_window_offset, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);



static void atom_host_done(struct snd_sof_dev *sdev)

{

	/* clear BUSY bit and set DONE bit - accept new messages */

	snd_sof_dsp_update_bits64_unlocked(sdev, DSP_BAR, SHIM_IPCD,

					   SHIM_BYT_IPCD_BUSY |

					   SHIM_BYT_IPCD_DONE,

					   SHIM_BYT_IPCD_DONE);



	/* unmask and prepare to receive next new message */

	snd_sof_dsp_update_bits64_unlocked(sdev, DSP_BAR, SHIM_IMRX,

					   SHIM_IMRX_BUSY, 0);

}



static void atom_dsp_done(struct snd_sof_dev *sdev)

{

	/* clear DONE bit - tell DSP we have completed */

	snd_sof_dsp_update_bits64_unlocked(sdev, DSP_BAR, SHIM_IPCX,

					   SHIM_BYT_IPCX_DONE, 0);

}



/*

 * DSP control.

 */



int atom_run(struct snd_sof_dev *sdev)

{

	int tries = 10;



	/* release stall and wait to unstall */

	snd_sof_dsp_update_bits64(sdev, DSP_BAR, SHIM_CSR,

				  SHIM_BYT_CSR_STALL, 0x0);

	while (tries--) {

		if (!(snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_CSR) &

		      SHIM_BYT_CSR_PWAITMODE))

			break;

		msleep(100);

	}

	if (tries < 0) {

		dev_err(sdev->dev, "error:  unable to run DSP firmware\n");

		atom_dump(sdev, SOF_DBG_DUMP_REGS | SOF_DBG_DUMP_MBOX);

		return -ENODEV;

	}



	/* return init core mask */

	return 1;

}

EXPORT_SYMBOL_NS(atom_run, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);



int atom_reset(struct snd_sof_dev *sdev)

{

	/* put DSP into reset, set reset vector and stall */

	snd_sof_dsp_update_bits64(sdev, DSP_BAR, SHIM_CSR,

				  SHIM_BYT_CSR_RST | SHIM_BYT_CSR_VECTOR_SEL |

				  SHIM_BYT_CSR_STALL,

				  SHIM_BYT_CSR_RST | SHIM_BYT_CSR_VECTOR_SEL |

				  SHIM_BYT_CSR_STALL);



	usleep_range(10, 15);



	/* take DSP out of reset and keep stalled for FW loading */

	snd_sof_dsp_update_bits64(sdev, DSP_BAR, SHIM_CSR,

				  SHIM_BYT_CSR_RST, 0);



	return 0;

}

EXPORT_SYMBOL_NS(atom_reset, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);



static const char *fixup_tplg_name(struct snd_sof_dev *sdev,

				   const char *sof_tplg_filename,

				   const char *ssp_str)

{

	const char *tplg_filename = NULL;

	char *filename;

	char *split_ext;



	filename = devm_kstrdup(sdev->dev, sof_tplg_filename, GFP_KERNEL);

	if (!filename)

		return NULL;



	/* this assumes a .tplg extension */

	split_ext = strsep(&filename, ".");

	if (split_ext) {

		tplg_filename = devm_kasprintf(sdev->dev, GFP_KERNEL,

					       "%s-%s.tplg",

					       split_ext, ssp_str);

		if (!tplg_filename)

			return NULL;

	}

	return tplg_filename;

}



void atom_machine_select(struct snd_sof_dev *sdev)

{

	struct snd_sof_pdata *sof_pdata = sdev->pdata;

	const struct sof_dev_desc *desc = sof_pdata->desc;

	struct snd_soc_acpi_mach *mach;

	struct platform_device *pdev;

	const char *tplg_filename;



	mach = snd_soc_acpi_find_machine(desc->machines);

	if (!mach) {

		dev_warn(sdev->dev, "warning: No matching ASoC machine driver found\n");

		return;

	}



	pdev = to_platform_device(sdev->dev);

	if (soc_intel_is_byt_cr(pdev)) {

		dev_dbg(sdev->dev,

			"BYT-CR detected, SSP0 used instead of SSP2\n");



		tplg_filename = fixup_tplg_name(sdev,

						mach->sof_tplg_filename,

						"ssp0");

	} else {

		tplg_filename = mach->sof_tplg_filename;

	}



	if (!tplg_filename) {

		dev_dbg(sdev->dev,

			"error: no topology filename\n");

		return;

	}



	sof_pdata->tplg_filename = tplg_filename;

	mach->mach_params.acpi_ipc_irq_index = desc->irqindex_host_ipc;

	sof_pdata->machine = mach;

}

EXPORT_SYMBOL_NS(atom_machine_select, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);



/* Atom DAIs */

struct snd_soc_dai_driver atom_dai[] = {

{

	.name = "ssp0-port",

	.playback = {

		.channels_min = 1,

		.channels_max = 8,

	},

	.capture = {

		.channels_min = 1,

		.channels_max = 8,

	},

},

{

	.name = "ssp1-port",

	.playback = {

		.channels_min = 1,

		.channels_max = 8,

	},

	.capture = {

		.channels_min = 1,

		.channels_max = 8,

	},

},

{

	.name = "ssp2-port",

	.playback = {

		.channels_min = 1,

		.channels_max = 8,

	},

	.capture = {

		.channels_min = 1,

		.channels_max = 8,

	}

},

{

	.name = "ssp3-port",

	.playback = {

		.channels_min = 1,

		.channels_max = 8,

	},

	.capture = {

		.channels_min = 1,

		.channels_max = 8,

	},

},

{

	.name = "ssp4-port",

	.playback = {

		.channels_min = 1,

		.channels_max = 8,

	},

	.capture = {

		.channels_min = 1,

		.channels_max = 8,

	},

},

{

	.name = "ssp5-port",

	.playback = {

		.channels_min = 1,

		.channels_max = 8,

	},

	.capture = {

		.channels_min = 1,

		.channels_max = 8,

	},

},

};

EXPORT_SYMBOL_NS(atom_dai, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);



void atom_set_mach_params(const struct snd_soc_acpi_mach *mach,

			  struct snd_sof_dev *sdev)

{

	struct snd_sof_pdata *pdata = sdev->pdata;

	const struct sof_dev_desc *desc = pdata->desc;

	struct snd_soc_acpi_mach_params *mach_params;



	mach_params = (struct snd_soc_acpi_mach_params *)&mach->mach_params;

	mach_params->platform = dev_name(sdev->dev);

	mach_params->num_dai_drivers = desc->ops->num_drv;

	mach_params->dai_drivers = desc->ops->drv;

}

EXPORT_SYMBOL_NS(atom_set_mach_params, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);



MODULE_LICENSE("Dual BSD/GPL");

sound/soc/sof/intel/atom.h

0 → 100644
+74 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */

/*

 * This file is provided under a dual BSD/GPLv2 license.  When using or

 * redistributing this file, you may do so under either license.

 *

 * Copyright(c) 2017-2021 Intel Corporation. All rights reserved.

 *

 * Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>

 */



#ifndef __SOF_INTEL_ATOM_H

#define __SOF_INTEL_ATOM_H



/* DSP memories */

#define IRAM_OFFSET		0x0C0000

#define IRAM_SIZE		(80 * 1024)

#define DRAM_OFFSET		0x100000

#define DRAM_SIZE		(160 * 1024)

#define SHIM_OFFSET		0x140000

#define SHIM_SIZE_BYT		0x100

#define SHIM_SIZE_CHT		0x118

#define MBOX_OFFSET		0x144000

#define MBOX_SIZE		0x1000

#define EXCEPT_OFFSET		0x800

#define EXCEPT_MAX_HDR_SIZE	0x400



/* DSP peripherals */

#define DMAC0_OFFSET		0x098000

#define DMAC1_OFFSET		0x09c000

#define DMAC2_OFFSET		0x094000

#define DMAC_SIZE		0x420

#define SSP0_OFFSET		0x0a0000

#define SSP1_OFFSET		0x0a1000

#define SSP2_OFFSET		0x0a2000

#define SSP3_OFFSET		0x0a4000

#define SSP4_OFFSET		0x0a5000

#define SSP5_OFFSET		0x0a6000

#define SSP_SIZE		0x100



#define STACK_DUMP_SIZE		32



#define PCI_BAR_SIZE		0x200000



#define PANIC_OFFSET(x)	(((x) & GENMASK_ULL(47, 32)) >> 32)



/*

 * Debug

 */



#define MBOX_DUMP_SIZE	0x30



/* BARs */

#define DSP_BAR		0

#define PCI_BAR		1

#define IMR_BAR		2



irqreturn_t atom_irq_handler(int irq, void *context);

irqreturn_t atom_irq_thread(int irq, void *context);



int atom_send_msg(struct snd_sof_dev *sdev, struct snd_sof_ipc_msg *msg);

int atom_get_mailbox_offset(struct snd_sof_dev *sdev);

int atom_get_window_offset(struct snd_sof_dev *sdev, u32 id);



int atom_run(struct snd_sof_dev *sdev);

int atom_reset(struct snd_sof_dev *sdev);

void atom_dump(struct snd_sof_dev *sdev, u32 flags);



void atom_machine_select(struct snd_sof_dev *sdev);

void atom_set_mach_params(const struct snd_soc_acpi_mach *mach,

			  struct snd_sof_dev *sdev);



extern struct snd_soc_dai_driver atom_dai[];



#endif

sound/soc/sof/intel/byt.c

+72 −696

File changed.

Preview size limit exceeded, changes collapsed.

sound/soc/sof/intel/pci-tng.c

+170 −1
Original line number Diff line number Diff line
@@ -14,7 +14,10 @@ 
#include <sound/soc-acpi-intel-match.h>

#include <sound/sof.h>

#include "../ops.h"

#include "atom.h"

#include "shim.h"

#include "../sof-pci-dev.h"

#include "../sof-audio.h"



/* platform specific devices */

#include "shim.h"
@@ -29,6 +32,170 @@ static struct snd_soc_acpi_mach sof_tng_machines[] = { 
	{}

};



static const struct snd_sof_debugfs_map tng_debugfs[] = {

	{"dmac0", DSP_BAR, DMAC0_OFFSET, DMAC_SIZE,

	 SOF_DEBUGFS_ACCESS_ALWAYS},

	{"dmac1", DSP_BAR, DMAC1_OFFSET, DMAC_SIZE,

	 SOF_DEBUGFS_ACCESS_ALWAYS},

	{"ssp0", DSP_BAR, SSP0_OFFSET, SSP_SIZE,

	 SOF_DEBUGFS_ACCESS_ALWAYS},

	{"ssp1", DSP_BAR, SSP1_OFFSET, SSP_SIZE,

	 SOF_DEBUGFS_ACCESS_ALWAYS},

	{"ssp2", DSP_BAR, SSP2_OFFSET, SSP_SIZE,

	 SOF_DEBUGFS_ACCESS_ALWAYS},

	{"iram", DSP_BAR, IRAM_OFFSET, IRAM_SIZE,

	 SOF_DEBUGFS_ACCESS_D0_ONLY},

	{"dram", DSP_BAR, DRAM_OFFSET, DRAM_SIZE,

	 SOF_DEBUGFS_ACCESS_D0_ONLY},

	{"shim", DSP_BAR, SHIM_OFFSET, SHIM_SIZE_BYT,

	 SOF_DEBUGFS_ACCESS_ALWAYS},

};



static int tangier_pci_probe(struct snd_sof_dev *sdev)

{

	struct snd_sof_pdata *pdata = sdev->pdata;

	const struct sof_dev_desc *desc = pdata->desc;

	struct pci_dev *pci = to_pci_dev(sdev->dev);

	u32 base, size;

	int ret;



	/* DSP DMA can only access low 31 bits of host memory */

	ret = dma_coerce_mask_and_coherent(&pci->dev, DMA_BIT_MASK(31));

	if (ret < 0) {

		dev_err(sdev->dev, "error: failed to set DMA mask %d\n", ret);

		return ret;

	}



	/* LPE base */

	base = pci_resource_start(pci, desc->resindex_lpe_base) - IRAM_OFFSET;

	size = PCI_BAR_SIZE;



	dev_dbg(sdev->dev, "LPE PHY base at 0x%x size 0x%x", base, size);

	sdev->bar[DSP_BAR] = devm_ioremap(sdev->dev, base, size);

	if (!sdev->bar[DSP_BAR]) {

		dev_err(sdev->dev, "error: failed to ioremap LPE base 0x%x size 0x%x\n",

			base, size);

		return -ENODEV;

	}

	dev_dbg(sdev->dev, "LPE VADDR %p\n", sdev->bar[DSP_BAR]);



	/* IMR base - optional */

	if (desc->resindex_imr_base == -1)

		goto irq;



	base = pci_resource_start(pci, desc->resindex_imr_base);

	size = pci_resource_len(pci, desc->resindex_imr_base);



	/* some BIOSes don't map IMR */

	if (base == 0x55aa55aa || base == 0x0) {

		dev_info(sdev->dev, "IMR not set by BIOS. Ignoring\n");

		goto irq;

	}



	dev_dbg(sdev->dev, "IMR base at 0x%x size 0x%x", base, size);

	sdev->bar[IMR_BAR] = devm_ioremap(sdev->dev, base, size);

	if (!sdev->bar[IMR_BAR]) {

		dev_err(sdev->dev, "error: failed to ioremap IMR base 0x%x size 0x%x\n",

			base, size);

		return -ENODEV;

	}

	dev_dbg(sdev->dev, "IMR VADDR %p\n", sdev->bar[IMR_BAR]);



irq:

	/* register our IRQ */

	sdev->ipc_irq = pci->irq;

	dev_dbg(sdev->dev, "using IRQ %d\n", sdev->ipc_irq);

	ret = devm_request_threaded_irq(sdev->dev, sdev->ipc_irq,

					atom_irq_handler, atom_irq_thread,

					0, "AudioDSP", sdev);

	if (ret < 0) {

		dev_err(sdev->dev, "error: failed to register IRQ %d\n",

			sdev->ipc_irq);

		return ret;

	}



	/* enable BUSY and disable DONE Interrupt by default */

	snd_sof_dsp_update_bits64(sdev, DSP_BAR, SHIM_IMRX,

				  SHIM_IMRX_BUSY | SHIM_IMRX_DONE,

				  SHIM_IMRX_DONE);



	/* set default mailbox offset for FW ready message */

	sdev->dsp_box.offset = MBOX_OFFSET;



	return ret;

}



const struct snd_sof_dsp_ops sof_tng_ops = {

	/* device init */

	.probe		= tangier_pci_probe,



	/* DSP core boot / reset */

	.run		= atom_run,

	.reset		= atom_reset,



	/* Register IO */

	.write		= sof_io_write,

	.read		= sof_io_read,

	.write64	= sof_io_write64,

	.read64		= sof_io_read64,



	/* Block IO */

	.block_read	= sof_block_read,

	.block_write	= sof_block_write,



	/* doorbell */

	.irq_handler	= atom_irq_handler,

	.irq_thread	= atom_irq_thread,



	/* ipc */

	.send_msg	= atom_send_msg,

	.fw_ready	= sof_fw_ready,

	.get_mailbox_offset = atom_get_mailbox_offset,

	.get_window_offset = atom_get_window_offset,



	.ipc_msg_data	= intel_ipc_msg_data,

	.ipc_pcm_params	= intel_ipc_pcm_params,



	/* machine driver */

	.machine_select = atom_machine_select,

	.machine_register = sof_machine_register,

	.machine_unregister = sof_machine_unregister,

	.set_mach_params = atom_set_mach_params,



	/* debug */

	.debug_map	= tng_debugfs,

	.debug_map_count	= ARRAY_SIZE(tng_debugfs),

	.dbg_dump	= atom_dump,



	/* stream callbacks */

	.pcm_open	= intel_pcm_open,

	.pcm_close	= intel_pcm_close,



	/* module loading */

	.load_module	= snd_sof_parse_module_memcpy,



	/*Firmware loading */

	.load_firmware	= snd_sof_load_firmware_memcpy,



	/* DAI drivers */

	.drv = atom_dai,

	.num_drv = 3, /* we have only 3 SSPs on byt*/



	/* ALSA HW info flags */

	.hw_info =	SNDRV_PCM_INFO_MMAP |

			SNDRV_PCM_INFO_MMAP_VALID |

			SNDRV_PCM_INFO_INTERLEAVED |

			SNDRV_PCM_INFO_PAUSE |

			SNDRV_PCM_INFO_BATCH,



	.arch_ops = &sof_xtensa_arch_ops,

};



const struct sof_intel_dsp_desc tng_chip_info = {

	.cores_num = 1,

	.host_managed_cores_mask = 1,

};



static const struct sof_dev_desc tng_desc = {

	.machines		= sof_tng_machines,

	.resindex_lpe_base	= 3,	/* IRAM, but subtract IRAM offset */
@@ -66,5 +233,7 @@ static struct pci_driver snd_sof_pci_intel_tng_driver = { 
module_pci_driver(snd_sof_pci_intel_tng_driver);



MODULE_LICENSE("Dual BSD/GPL");

MODULE_IMPORT_NS(SND_SOC_SOF_MERRIFIELD);

MODULE_IMPORT_NS(SND_SOC_SOF_INTEL_HIFI_EP_IPC);

MODULE_IMPORT_NS(SND_SOC_SOF_XTENSA);

MODULE_IMPORT_NS(SND_SOC_SOF_PCI_DEV);

MODULE_IMPORT_NS(SND_SOC_SOF_INTEL_ATOM_HIFI_EP);