Commit 1da2b3ee authored by Ashutosh Dixit's avatar Ashutosh Dixit Committed by Greg Kroah-Hartman
Browse files

misc: mic: Remove COSM functionality from the MIC host driver 



Since COSM functionality is now moved into a separate COSM driver
drivers, this patch removes this functionality from the base MIC host
driver. The MIC host driver now implements cosm_hw_ops and registers a
COSM device which allows the COSM driver to trigger
boot/shutdown/reset of the MIC devices via the cosm_hw_ops.

Reviewed-by: default avatarNikhil Rao <nikhil.rao@intel.com>
Reviewed-by: default avatarSudeep Dutt <sudeep.dutt@intel.com>
Signed-off-by: default avatarDasaratharaman Chandramouli <dasaratharaman.chandramouli@intel.com>
Signed-off-by: default avatarAshutosh Dixit <ashutosh.dixit@intel.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 7cb46d9b

drivers/misc/mic/Makefile

+0 −2
Original line number Diff line number Diff line
@@ -2,7 +2,5 @@ 
# Makefile - Intel MIC Linux driver.

# Copyright(c) 2013, Intel Corporation.

#

obj-$(CONFIG_INTEL_MIC_HOST) += host/

obj-$(CONFIG_INTEL_MIC_CARD) += card/

obj-y += bus/

obj-$(CONFIG_SCIF) += scif/

drivers/misc/mic/host/Makefile

+0 −1
Original line number Diff line number Diff line
@@ -5,7 +5,6 @@ 
obj-$(CONFIG_INTEL_MIC_HOST) += mic_host.o

mic_host-objs := mic_main.o

mic_host-objs += mic_x100.o

mic_host-objs += mic_sysfs.o

mic_host-objs += mic_smpt.o

mic_host-objs += mic_intr.o

mic_host-objs += mic_boot.o

drivers/misc/mic/host/mic_boot.c

+87 −230
Original line number Diff line number Diff line
@@ -22,9 +22,9 @@ 
#include <linux/firmware.h>

#include <linux/pci.h>

#include <linux/kmod.h>



#include <linux/mic_common.h>

#include <linux/mic_bus.h>

#include "../bus/scif_bus.h"

#include "../common/mic_dev.h"

#include "mic_device.h"

#include "mic_smpt.h"
@@ -99,7 +99,7 @@ static int __mic_dma_map_sg(struct device *dev, struct scatterlist *sg, 
	int i, j, ret;

	dma_addr_t da;



	ret = dma_map_sg(mdev->sdev->parent, sg, nents, dir);

	ret = dma_map_sg(&mdev->pdev->dev, sg, nents, dir);

	if (ret <= 0)

		return 0;
@@ -115,7 +115,7 @@ err: 
		mic_unmap(mdev, sg_dma_address(s), s->length);

		sg_dma_address(s) = mic_to_dma_addr(mdev, sg_dma_address(s));

	}

	dma_unmap_sg(mdev->sdev->parent, sg, nents, dir);

	dma_unmap_sg(&mdev->pdev->dev, sg, nents, dir);

	return 0;

}
@@ -135,7 +135,7 @@ static void __mic_dma_unmap_sg(struct device *dev, 
		mic_unmap(mdev, sg_dma_address(s), s->length);

		sg_dma_address(s) = da;

	}

	dma_unmap_sg(mdev->sdev->parent, sg, nents, dir);

	dma_unmap_sg(&mdev->pdev->dev, sg, nents, dir);

}



static struct dma_map_ops __mic_dma_ops = {
@@ -270,48 +270,13 @@ static struct mbus_hw_ops mbus_hw_ops = { 
	.ack_interrupt = _mic_ack_interrupt,

};



/**

 * mic_reset - Reset the MIC device.

 * @mdev: pointer to mic_device instance

 */

static void mic_reset(struct mic_device *mdev)

{

	int i;



#define MIC_RESET_TO (45)



	reinit_completion(&mdev->reset_wait);

	mdev->ops->reset_fw_ready(mdev);

	mdev->ops->reset(mdev);



	for (i = 0; i < MIC_RESET_TO; i++) {

		if (mdev->ops->is_fw_ready(mdev))

			goto done;

		/*

		 * Resets typically take 10s of seconds to complete.

		 * Since an MMIO read is required to check if the

		 * firmware is ready or not, a 1 second delay works nicely.

		 */

		msleep(1000);

	}

	mic_set_state(mdev, MIC_RESET_FAILED);

done:

	complete_all(&mdev->reset_wait);

}



/* Initialize the MIC bootparams */

void mic_bootparam_init(struct mic_device *mdev)

{

	struct mic_bootparam *bootparam = mdev->dp;



	bootparam->magic = cpu_to_le32(MIC_MAGIC);

	bootparam->c2h_shutdown_db = mdev->shutdown_db;

	bootparam->h2c_shutdown_db = -1;

	bootparam->h2c_config_db = -1;

	bootparam->shutdown_status = 0;

	bootparam->shutdown_card = 0;

	/* Total nodes = number of MICs + 1 for self node */

	bootparam->tot_nodes = atomic_read(&g_num_mics) + 1;

	bootparam->node_id = mdev->id + 1;

	bootparam->scif_host_dma_addr = 0x0;

	bootparam->scif_card_dma_addr = 0x0;
@@ -319,6 +284,26 @@ void mic_bootparam_init(struct mic_device *mdev) 
	bootparam->h2c_scif_db = -1;

}



static inline struct mic_device *cosmdev_to_mdev(struct cosm_device *cdev)

{

	return dev_get_drvdata(cdev->dev.parent);

}



static void _mic_reset(struct cosm_device *cdev)

{

	struct mic_device *mdev = cosmdev_to_mdev(cdev);



	mdev->ops->reset_fw_ready(mdev);

	mdev->ops->reset(mdev);

}



static bool _mic_ready(struct cosm_device *cdev)

{

	struct mic_device *mdev = cosmdev_to_mdev(cdev);



	return mdev->ops->is_fw_ready(mdev);

}



/**

 * mic_request_dma_chans - Request DMA channels

 * @mdev: pointer to mic_device instance
@@ -336,14 +321,14 @@ static int mic_request_dma_chans(struct mic_device *mdev) 


	do {

		chan = dma_request_channel(mask, mdev->ops->dma_filter,

					   mdev->sdev->parent);

					   &mdev->pdev->dev);

		if (chan) {

			mdev->dma_ch[mdev->num_dma_ch++] = chan;

			if (mdev->num_dma_ch >= MIC_MAX_DMA_CHAN)

				break;

		}

	} while (chan);

	dev_info(mdev->sdev->parent, "DMA channels # %d\n", mdev->num_dma_ch);

	dev_info(&mdev->pdev->dev, "DMA channels # %d\n", mdev->num_dma_ch);

	return mdev->num_dma_ch;

}
@@ -365,34 +350,24 @@ static void mic_free_dma_chans(struct mic_device *mdev) 
}



/**

 * mic_start - Start the MIC.

 * @mdev: pointer to mic_device instance

 * @buf: buffer containing boot string including firmware/ramdisk path.

 * _mic_start - Start the MIC.

 * @cdev: pointer to cosm_device instance

 * @id: MIC device id/index provided by COSM used in other drivers like SCIF

 *

 * This function prepares an MIC for boot and initiates boot.

 * RETURNS: An appropriate -ERRNO error value on error, or zero for success.

 *

 * For all cosm_hw_ops the caller holds a mutex to ensure serialization.

 */

int mic_start(struct mic_device *mdev, const char *buf)

static int _mic_start(struct cosm_device *cdev, int id)

{

	struct mic_device *mdev = cosmdev_to_mdev(cdev);

	int rc;

	mutex_lock(&mdev->mic_mutex);



	mic_bootparam_init(mdev);

retry:

	if (MIC_OFFLINE != mdev->state) {

		rc = -EINVAL;

		goto unlock_ret;

	}

	if (!mdev->ops->is_fw_ready(mdev)) {

		mic_reset(mdev);

		/*

		 * The state will either be MIC_OFFLINE if the reset succeeded

		 * or MIC_RESET_FAILED if the firmware reset failed.

		 */

		goto retry;

	}

	mdev->dma_mbdev = mbus_register_device(mdev->sdev->parent,

	mdev->dma_mbdev = mbus_register_device(&mdev->pdev->dev,

					       MBUS_DEV_DMA_HOST, &mic_dma_ops,

					       &mbus_hw_ops, mdev->mmio.va);

					       &mbus_hw_ops, id, mdev->mmio.va);

	if (IS_ERR(mdev->dma_mbdev)) {

		rc = PTR_ERR(mdev->dma_mbdev);

		goto unlock_ret;
@@ -401,16 +376,18 @@ retry: 
		rc = -ENODEV;

		goto dma_remove;

	}

	mdev->scdev = scif_register_device(mdev->sdev->parent, MIC_SCIF_DEV,

	mdev->scdev = scif_register_device(&mdev->pdev->dev, MIC_SCIF_DEV,

					   &__mic_dma_ops, &scif_hw_ops,

					   mdev->id + 1, 0, &mdev->mmio,

					   id + 1, 0, &mdev->mmio,

					   &mdev->aper, mdev->dp, NULL,

					   mdev->dma_ch, mdev->num_dma_ch);

					   mdev->dma_ch, mdev->num_dma_ch,

					   true);

	if (IS_ERR(mdev->scdev)) {

		rc = PTR_ERR(mdev->scdev);

		goto dma_free;

	}

	rc = mdev->ops->load_mic_fw(mdev, buf);



	rc = mdev->ops->load_mic_fw(mdev, NULL);

	if (rc)

		goto scif_remove;

	mic_smpt_restore(mdev);
@@ -419,7 +396,6 @@ retry: 
	mdev->ops->write_spad(mdev, MIC_DPLO_SPAD, mdev->dp_dma_addr);

	mdev->ops->write_spad(mdev, MIC_DPHI_SPAD, mdev->dp_dma_addr >> 32);

	mdev->ops->send_firmware_intr(mdev);

	mic_set_state(mdev, MIC_ONLINE);

	goto unlock_ret;

scif_remove:

	scif_unregister_device(mdev->scdev);
@@ -428,198 +404,79 @@ dma_free: 
dma_remove:

	mbus_unregister_device(mdev->dma_mbdev);

unlock_ret:

	mutex_unlock(&mdev->mic_mutex);

	return rc;

}



/**

 * mic_stop - Prepare the MIC for reset and trigger reset.

 * @mdev: pointer to mic_device instance

 * _mic_stop - Prepare the MIC for reset and trigger reset.

 * @cdev: pointer to cosm_device instance

 * @force: force a MIC to reset even if it is already offline.

 *

 * RETURNS: None.

 */

void mic_stop(struct mic_device *mdev, bool force)

static void _mic_stop(struct cosm_device *cdev, bool force)

{

	mutex_lock(&mdev->mic_mutex);

	if (MIC_OFFLINE != mdev->state || force) {

		scif_unregister_device(mdev->scdev);

	struct mic_device *mdev = cosmdev_to_mdev(cdev);



	/*

	 * Since SCIF handles card shutdown and reset (using COSM), it will

	 * will be the first to be registered and the last to be

	 * unregistered.

	 */

	mic_virtio_reset_devices(mdev);

	scif_unregister_device(mdev->scdev);

	mic_free_dma_chans(mdev);

	mbus_unregister_device(mdev->dma_mbdev);

	mic_bootparam_init(mdev);

		mic_reset(mdev);

		if (MIC_RESET_FAILED == mdev->state)

			goto unlock;

		mic_set_shutdown_status(mdev, MIC_NOP);

		if (MIC_SUSPENDED != mdev->state)

			mic_set_state(mdev, MIC_OFFLINE);

	}

unlock:

	mutex_unlock(&mdev->mic_mutex);

}



/**

 * mic_shutdown - Initiate MIC shutdown.

 * @mdev: pointer to mic_device instance

 *

 * RETURNS: None.

 */

void mic_shutdown(struct mic_device *mdev)

{

	struct mic_bootparam *bootparam = mdev->dp;

	s8 db = bootparam->h2c_shutdown_db;



	mutex_lock(&mdev->mic_mutex);

	if (MIC_ONLINE == mdev->state && db != -1) {

		bootparam->shutdown_card = 1;

		mdev->ops->send_intr(mdev, db);

		mic_set_state(mdev, MIC_SHUTTING_DOWN);

	}

	mutex_unlock(&mdev->mic_mutex);

}



/**

 * mic_shutdown_work - Handle shutdown interrupt from MIC.

 * @work: The work structure.

 *

 * This work is scheduled whenever the host has received a shutdown

 * interrupt from the MIC.

 */

void mic_shutdown_work(struct work_struct *work)

static ssize_t _mic_family(struct cosm_device *cdev, char *buf)

{

	struct mic_device *mdev = container_of(work, struct mic_device,

			shutdown_work);

	struct mic_bootparam *bootparam = mdev->dp;



	mutex_lock(&mdev->mic_mutex);

	mic_set_shutdown_status(mdev, bootparam->shutdown_status);

	bootparam->shutdown_status = 0;

	struct mic_device *mdev = cosmdev_to_mdev(cdev);

	static const char *family[MIC_FAMILY_LAST] = { "x100", "Unknown" };



	/*

	 * if state is MIC_SUSPENDED, OSPM suspend is in progress. We do not

	 * change the state here so as to prevent users from booting the card

	 * during and after the suspend operation.

	 */

	if (MIC_SHUTTING_DOWN != mdev->state &&

	    MIC_SUSPENDED != mdev->state)

		mic_set_state(mdev, MIC_SHUTTING_DOWN);

	mutex_unlock(&mdev->mic_mutex);

	return scnprintf(buf, PAGE_SIZE, "%s\n", family[mdev->family]);

}



/**

 * mic_reset_trigger_work - Trigger MIC reset.

 * @work: The work structure.

 *

 * This work is scheduled whenever the host wants to reset the MIC.

 */

void mic_reset_trigger_work(struct work_struct *work)

static ssize_t _mic_stepping(struct cosm_device *cdev, char *buf)

{

	struct mic_device *mdev = container_of(work, struct mic_device,

			reset_trigger_work);



	mic_stop(mdev, false);

}



/**

 * mic_complete_resume - Complete MIC Resume after an OSPM suspend/hibernate

 * event.

 * @mdev: pointer to mic_device instance

 *

 * RETURNS: None.

 */

void mic_complete_resume(struct mic_device *mdev)

{

	if (mdev->state != MIC_SUSPENDED) {

		dev_warn(mdev->sdev->parent, "state %d should be %d\n",

			 mdev->state, MIC_SUSPENDED);

		return;

	}



	/* Make sure firmware is ready */

	if (!mdev->ops->is_fw_ready(mdev))

		mic_stop(mdev, true);



	mutex_lock(&mdev->mic_mutex);

	mic_set_state(mdev, MIC_OFFLINE);

	mutex_unlock(&mdev->mic_mutex);

}

	struct mic_device *mdev = cosmdev_to_mdev(cdev);

	const char *string = "??";



/**

 * mic_prepare_suspend - Handle suspend notification for the MIC device.

 * @mdev: pointer to mic_device instance

 *

 * RETURNS: None.

 */

void mic_prepare_suspend(struct mic_device *mdev)

{

	unsigned long timeout;



#define MIC_SUSPEND_TIMEOUT (60 * HZ)



	mutex_lock(&mdev->mic_mutex);

	switch (mdev->state) {

	case MIC_OFFLINE:

		/*

		 * Card is already offline. Set state to MIC_SUSPENDED

		 * to prevent users from booting the card.

		 */

		mic_set_state(mdev, MIC_SUSPENDED);

		mutex_unlock(&mdev->mic_mutex);

	switch (mdev->stepping) {

	case MIC_A0_STEP:

		string = "A0";

		break;

	case MIC_ONLINE:

		/*

		 * Card is online. Set state to MIC_SUSPENDING and notify

		 * MIC user space daemon which will issue card

		 * shutdown and reset.

		 */

		mic_set_state(mdev, MIC_SUSPENDING);

		mutex_unlock(&mdev->mic_mutex);

		timeout = wait_for_completion_timeout(&mdev->reset_wait,

						      MIC_SUSPEND_TIMEOUT);

		/* Force reset the card if the shutdown completion timed out */

		if (!timeout) {

			mutex_lock(&mdev->mic_mutex);

			mic_set_state(mdev, MIC_SUSPENDED);

			mutex_unlock(&mdev->mic_mutex);

			mic_stop(mdev, true);

		}

	case MIC_B0_STEP:

		string = "B0";

		break;

	case MIC_SHUTTING_DOWN:

		/*

		 * Card is shutting down. Set state to MIC_SUSPENDED

		 * to prevent further boot of the card.

		 */

		mic_set_state(mdev, MIC_SUSPENDED);

		mutex_unlock(&mdev->mic_mutex);

		timeout = wait_for_completion_timeout(&mdev->reset_wait,

						      MIC_SUSPEND_TIMEOUT);

		/* Force reset the card if the shutdown completion timed out */

		if (!timeout)

			mic_stop(mdev, true);

	case MIC_B1_STEP:

		string = "B1";

		break;

	case MIC_C0_STEP:

		string = "C0";

		break;

	default:

		mutex_unlock(&mdev->mic_mutex);

		break;

	}

	return scnprintf(buf, PAGE_SIZE, "%s\n", string);

}



/**

 * mic_suspend - Initiate MIC suspend. Suspend merely issues card shutdown.

 * @mdev: pointer to mic_device instance

 *

 * RETURNS: None.

 */

void mic_suspend(struct mic_device *mdev)

static struct mic_mw *_mic_aper(struct cosm_device *cdev)

{

	struct mic_bootparam *bootparam = mdev->dp;

	s8 db = bootparam->h2c_shutdown_db;

	struct mic_device *mdev = cosmdev_to_mdev(cdev);



	mutex_lock(&mdev->mic_mutex);

	if (MIC_SUSPENDING == mdev->state && db != -1) {

		bootparam->shutdown_card = 1;

		mdev->ops->send_intr(mdev, db);

		mic_set_state(mdev, MIC_SUSPENDED);

	}

	mutex_unlock(&mdev->mic_mutex);

	return &mdev->aper;

}



struct cosm_hw_ops cosm_hw_ops = {

	.reset = _mic_reset,

	.force_reset = _mic_reset,

	.post_reset = NULL,

	.ready = _mic_ready,

	.start = _mic_start,

	.stop = _mic_stop,

	.family = _mic_family,

	.stepping = _mic_stepping,

	.aper = _mic_aper,

};

drivers/misc/mic/host/mic_debugfs.c

+5 −109
Original line number Diff line number Diff line
@@ -31,71 +31,6 @@ 
/* Debugfs parent dir */

static struct dentry *mic_dbg;



/**

 * mic_log_buf_show - Display MIC kernel log buffer.

 *

 * log_buf addr/len is read from System.map by user space

 * and populated in sysfs entries.

 */

static int mic_log_buf_show(struct seq_file *s, void *unused)

{

	void __iomem *log_buf_va;

	int __iomem *log_buf_len_va;

	struct mic_device *mdev = s->private;

	void *kva;

	int size;

	unsigned long aper_offset;



	if (!mdev || !mdev->log_buf_addr || !mdev->log_buf_len)

		goto done;

	/*

	 * Card kernel will never be relocated and any kernel text/data mapping

	 * can be translated to phys address by subtracting __START_KERNEL_map.

	 */

	aper_offset = (unsigned long)mdev->log_buf_len - __START_KERNEL_map;

	log_buf_len_va = mdev->aper.va + aper_offset;

	aper_offset = (unsigned long)mdev->log_buf_addr - __START_KERNEL_map;

	log_buf_va = mdev->aper.va + aper_offset;

	size = ioread32(log_buf_len_va);



	kva = kmalloc(size, GFP_KERNEL);

	if (!kva)

		goto done;

	mutex_lock(&mdev->mic_mutex);

	memcpy_fromio(kva, log_buf_va, size);

	switch (mdev->state) {

	case MIC_ONLINE:

		/* Fall through */

	case MIC_SHUTTING_DOWN:

		seq_write(s, kva, size);

		break;

	default:

		break;

	}

	mutex_unlock(&mdev->mic_mutex);

	kfree(kva);

done:

	return 0;

}



static int mic_log_buf_open(struct inode *inode, struct file *file)

{

	return single_open(file, mic_log_buf_show, inode->i_private);

}



static int mic_log_buf_release(struct inode *inode, struct file *file)

{

	return single_release(inode, file);

}



static const struct file_operations log_buf_ops = {

	.owner   = THIS_MODULE,

	.open    = mic_log_buf_open,

	.read    = seq_read,

	.llseek  = seq_lseek,

	.release = mic_log_buf_release

};



static int mic_smpt_show(struct seq_file *s, void *pos)

{

	int i;
@@ -138,32 +73,6 @@ static const struct file_operations smpt_file_ops = { 
	.release = mic_smpt_debug_release

};



static int mic_soft_reset_show(struct seq_file *s, void *pos)

{

	struct mic_device *mdev = s->private;



	mic_stop(mdev, true);

	return 0;

}



static int mic_soft_reset_debug_open(struct inode *inode, struct file *file)

{

	return single_open(file, mic_soft_reset_show, inode->i_private);

}



static int mic_soft_reset_debug_release(struct inode *inode, struct file *file)

{

	return single_release(inode, file);

}



static const struct file_operations soft_reset_ops = {

	.owner   = THIS_MODULE,

	.open    = mic_soft_reset_debug_open,

	.read    = seq_read,

	.llseek  = seq_lseek,

	.release = mic_soft_reset_debug_release

};



static int mic_post_code_show(struct seq_file *s, void *pos)

{

	struct mic_device *mdev = s->private;
@@ -204,18 +113,8 @@ static int mic_dp_show(struct seq_file *s, void *pos) 


	seq_printf(s, "Bootparam: magic 0x%x\n",

		   bootparam->magic);

	seq_printf(s, "Bootparam: h2c_shutdown_db %d\n",

		   bootparam->h2c_shutdown_db);

	seq_printf(s, "Bootparam: h2c_config_db %d\n",

		   bootparam->h2c_config_db);

	seq_printf(s, "Bootparam: c2h_shutdown_db %d\n",

		   bootparam->c2h_shutdown_db);

	seq_printf(s, "Bootparam: shutdown_status %d\n",

		   bootparam->shutdown_status);

	seq_printf(s, "Bootparam: shutdown_card %d\n",

		   bootparam->shutdown_card);

	seq_printf(s, "Bootparam: tot_nodes %d\n",

		   bootparam->tot_nodes);

	seq_printf(s, "Bootparam: node_id %d\n",

		   bootparam->node_id);

	seq_printf(s, "Bootparam: c2h_scif_db %d\n",
@@ -392,8 +291,7 @@ static int mic_msi_irq_info_show(struct seq_file *s, void *pos) 
	int i, j;

	u16 entry;

	u16 vector;

	struct pci_dev *pdev = container_of(mdev->sdev->parent,

		struct pci_dev, dev);

	struct pci_dev *pdev = mdev->pdev;



	if (pci_dev_msi_enabled(pdev)) {

		for (i = 0; i < mdev->irq_info.num_vectors; i++) {
@@ -454,20 +352,18 @@ static const struct file_operations msi_irq_info_ops = { 
 */

void mic_create_debug_dir(struct mic_device *mdev)

{

	char name[16];



	if (!mic_dbg)

		return;



	mdev->dbg_dir = debugfs_create_dir(dev_name(mdev->sdev), mic_dbg);

	scnprintf(name, sizeof(name), "mic%d", mdev->id);

	mdev->dbg_dir = debugfs_create_dir(name, mic_dbg);

	if (!mdev->dbg_dir)

		return;



	debugfs_create_file("log_buf", 0444, mdev->dbg_dir, mdev, &log_buf_ops);



	debugfs_create_file("smpt", 0444, mdev->dbg_dir, mdev, &smpt_file_ops);



	debugfs_create_file("soft_reset", 0444, mdev->dbg_dir, mdev,

			    &soft_reset_ops);



	debugfs_create_file("post_code", 0444, mdev->dbg_dir, mdev,

			    &post_code_ops);

drivers/misc/mic/host/mic_device.h

+12 −76
Original line number Diff line number Diff line
@@ -26,21 +26,12 @@ 
#include <linux/notifier.h>

#include <linux/irqreturn.h>

#include <linux/dmaengine.h>

#include <linux/miscdevice.h>

#include <linux/mic_bus.h>

#include "../bus/scif_bus.h"

#include "../bus/cosm_bus.h"

#include "mic_intr.h"



/* The maximum number of MIC devices supported in a single host system. */

#define MIC_MAX_NUM_DEVS 256



/**

 * enum mic_hw_family - The hardware family to which a device belongs.

 */

enum mic_hw_family {

	MIC_FAMILY_X100 = 0,

	MIC_FAMILY_UNKNOWN

};



/**

 * enum mic_stepping - MIC stepping ids.

 */
@@ -51,6 +42,8 @@ enum mic_stepping { 
	MIC_C0_STEP = 0x20,

};



extern struct cosm_hw_ops cosm_hw_ops;



/**

 * struct mic_device -  MIC device information for each card.

 *
@@ -60,8 +53,7 @@ enum mic_stepping { 
 * @ops: MIC HW specific operations.

 * @id: The unique device id for this MIC device.

 * @stepping: Stepping ID.

 * @attr_group: Pointer to list of sysfs attribute groups.

 * @sdev: Device for sysfs entries.

 * @pdev: Underlying PCI device.

 * @mic_mutex: Mutex for synchronizing access to mic_device.

 * @intr_ops: HW specific interrupt operations.

 * @smpt_ops: Hardware specific SMPT operations.
@@ -69,30 +61,17 @@ enum mic_stepping { 
 * @intr_info: H/W specific interrupt information.

 * @irq_info: The OS specific irq information

 * @dbg_dir: debugfs directory of this MIC device.

 * @cmdline: Kernel command line.

 * @firmware: Firmware file name.

 * @ramdisk: Ramdisk file name.

 * @bootmode: Boot mode i.e. "linux" or "elf" for flash updates.

 * @bootaddr: MIC boot address.

 * @reset_trigger_work: Work for triggering reset requests.

 * @shutdown_work: Work for handling shutdown interrupts.

 * @state: MIC state.

 * @shutdown_status: MIC status reported by card for shutdown/crashes.

 * @state_sysfs: Sysfs dirent for notifying ring 3 about MIC state changes.

 * @reset_wait: Waitqueue for sleeping while reset completes.

 * @log_buf_addr: Log buffer address for MIC.

 * @log_buf_len: Log buffer length address for MIC.

 * @dp: virtio device page

 * @dp_dma_addr: virtio device page DMA address.

 * @shutdown_db: shutdown doorbell.

 * @shutdown_cookie: shutdown cookie.

 * @cdev: Character device for MIC.

 * @name: name for the misc char device

 * @miscdev: registered misc char device

 * @vdev_list: list of virtio devices.

 * @pm_notifier: Handles PM notifications from the OS.

 * @dma_mbdev: MIC BUS DMA device.

 * @dma_ch - Array of DMA channels

 * @num_dma_ch - Number of DMA channels available

 * @scdev: SCIF device on the SCIF virtual bus.

 * @cosm_dev: COSM device

 */

struct mic_device {

	struct mic_mw mmio;
@@ -101,8 +80,7 @@ struct mic_device { 
	struct mic_hw_ops *ops;

	int id;

	enum mic_stepping stepping;

	const struct attribute_group **attr_group;

	struct device *sdev;

	struct pci_dev *pdev;

	struct mutex mic_mutex;

	struct mic_hw_intr_ops *intr_ops;

	struct mic_smpt_ops *smpt_ops;
@@ -110,30 +88,17 @@ struct mic_device { 
	struct mic_intr_info *intr_info;

	struct mic_irq_info irq_info;

	struct dentry *dbg_dir;

	char *cmdline;

	char *firmware;

	char *ramdisk;

	char *bootmode;

	u32 bootaddr;

	struct work_struct reset_trigger_work;

	struct work_struct shutdown_work;

	u8 state;

	u8 shutdown_status;

	struct kernfs_node *state_sysfs;

	struct completion reset_wait;

	void *log_buf_addr;

	int *log_buf_len;

	void *dp;

	dma_addr_t dp_dma_addr;

	int shutdown_db;

	struct mic_irq *shutdown_cookie;

	struct cdev cdev;

	char name[16];

	struct miscdevice miscdev;

	struct list_head vdev_list;

	struct notifier_block pm_notifier;

	struct mbus_device *dma_mbdev;

	struct dma_chan *dma_ch[MIC_MAX_DMA_CHAN];

	int num_dma_ch;

	struct scif_hw_dev *scdev;

	struct cosm_device *cosm_dev;

};



/**
@@ -199,38 +164,9 @@ mic_mmio_write(struct mic_mw *mw, u32 val, u32 offset) 
	iowrite32(val, mw->va + offset);

}



static inline struct dma_chan *mic_request_dma_chan(struct mic_device *mdev)

{

	dma_cap_mask_t mask;

	struct dma_chan *chan;



	dma_cap_zero(mask);

	dma_cap_set(DMA_MEMCPY, mask);

	chan = dma_request_channel(mask, mdev->ops->dma_filter,

				   mdev->sdev->parent);

	if (chan)

		return chan;

	dev_err(mdev->sdev->parent, "%s %d unable to acquire channel\n",

		__func__, __LINE__);

	return NULL;

}



void mic_sysfs_init(struct mic_device *mdev);

int mic_start(struct mic_device *mdev, const char *buf);

void mic_stop(struct mic_device *mdev, bool force);

void mic_shutdown(struct mic_device *mdev);

void mic_reset_delayed_work(struct work_struct *work);

void mic_reset_trigger_work(struct work_struct *work);

void mic_shutdown_work(struct work_struct *work);

void mic_bootparam_init(struct mic_device *mdev);

void mic_set_state(struct mic_device *mdev, u8 state);

void mic_set_shutdown_status(struct mic_device *mdev, u8 status);

void mic_create_debug_dir(struct mic_device *dev);

void mic_delete_debug_dir(struct mic_device *dev);

void __init mic_init_debugfs(void);

void mic_exit_debugfs(void);

void mic_prepare_suspend(struct mic_device *mdev);

void mic_complete_resume(struct mic_device *mdev);

void mic_suspend(struct mic_device *mdev);

extern atomic_t g_num_mics;

#endif

CRA Git | Maintained and supported by SUSTech CRA and CCSE