Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 74321d4c authored by Sudeep Dutt's avatar Sudeep Dutt Committed by Greg Kroah-Hartman
Browse files

misc: mic: MIC host driver specific changes to enable SCIF 



MIC host driver specific changes to enable SCIF. This patch implements
the SCIF hardware bus operations and registers a SCIF device on the
SCIF hardware bus.

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

drivers/misc/mic/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -36,7 +36,7 @@ comment "Intel MIC Host Driver" 


config INTEL_MIC_HOST

	tristate "Intel MIC Host Driver"

	depends on 64BIT && PCI && X86 && INTEL_MIC_BUS

	depends on 64BIT && PCI && X86 && INTEL_MIC_BUS && SCIF_BUS

	select VHOST_RING

	help

	  This enables Host Driver support for the Intel Many Integrated

drivers/misc/mic/host/mic_boot.c

+254 −10
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#include <linux/delay.h>

#include <linux/firmware.h>

#include <linux/pci.h>

#include <linux/kmod.h>



#include <linux/mic_common.h>

#include <linux/mic_bus.h>
@@ -29,6 +30,188 @@ 
#include "mic_smpt.h"

#include "mic_virtio.h"



static inline struct mic_device *scdev_to_mdev(struct scif_hw_dev *scdev)

{

	return dev_get_drvdata(scdev->dev.parent);

}



static void *__mic_dma_alloc(struct device *dev, size_t size,

			     dma_addr_t *dma_handle, gfp_t gfp,

			     struct dma_attrs *attrs)

{

	struct scif_hw_dev *scdev = dev_get_drvdata(dev);

	struct mic_device *mdev = scdev_to_mdev(scdev);

	dma_addr_t tmp;

	void *va = kmalloc(size, gfp);



	if (va) {

		tmp = mic_map_single(mdev, va, size);

		if (dma_mapping_error(dev, tmp)) {

			kfree(va);

			va = NULL;

		} else {

			*dma_handle = tmp;

		}

	}

	return va;

}



static void __mic_dma_free(struct device *dev, size_t size, void *vaddr,

			   dma_addr_t dma_handle, struct dma_attrs *attrs)

{

	struct scif_hw_dev *scdev = dev_get_drvdata(dev);

	struct mic_device *mdev = scdev_to_mdev(scdev);



	mic_unmap_single(mdev, dma_handle, size);

	kfree(vaddr);

}



static dma_addr_t

__mic_dma_map_page(struct device *dev, struct page *page, unsigned long offset,

		   size_t size, enum dma_data_direction dir,

		   struct dma_attrs *attrs)

{

	void *va = phys_to_virt(page_to_phys(page)) + offset;

	struct scif_hw_dev *scdev = dev_get_drvdata(dev);

	struct mic_device *mdev = scdev_to_mdev(scdev);



	return mic_map_single(mdev, va, size);

}



static void

__mic_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,

		     size_t size, enum dma_data_direction dir,

		     struct dma_attrs *attrs)

{

	struct scif_hw_dev *scdev = dev_get_drvdata(dev);

	struct mic_device *mdev = scdev_to_mdev(scdev);



	mic_unmap_single(mdev, dma_addr, size);

}



static int __mic_dma_map_sg(struct device *dev, struct scatterlist *sg,

			    int nents, enum dma_data_direction dir,

			    struct dma_attrs *attrs)

{

	struct scif_hw_dev *scdev = dev_get_drvdata(dev);

	struct mic_device *mdev = scdev_to_mdev(scdev);

	struct scatterlist *s;

	int i, j, ret;

	dma_addr_t da;



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

	if (ret <= 0)

		return 0;



	for_each_sg(sg, s, nents, i) {

		da = mic_map(mdev, sg_dma_address(s) + s->offset, s->length);

		if (!da)

			goto err;

		sg_dma_address(s) = da;

	}

	return nents;

err:

	for_each_sg(sg, s, i, j) {

		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);

	return 0;

}



static void __mic_dma_unmap_sg(struct device *dev,

			       struct scatterlist *sg, int nents,

			       enum dma_data_direction dir,

			       struct dma_attrs *attrs)

{

	struct scif_hw_dev *scdev = dev_get_drvdata(dev);

	struct mic_device *mdev = scdev_to_mdev(scdev);

	struct scatterlist *s;

	dma_addr_t da;

	int i;



	for_each_sg(sg, s, nents, i) {

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

		mic_unmap(mdev, sg_dma_address(s), s->length);

		sg_dma_address(s) = da;

	}

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

}



static struct dma_map_ops __mic_dma_ops = {

	.alloc = __mic_dma_alloc,

	.free = __mic_dma_free,

	.map_page = __mic_dma_map_page,

	.unmap_page = __mic_dma_unmap_page,

	.map_sg = __mic_dma_map_sg,

	.unmap_sg = __mic_dma_unmap_sg,

};



static struct mic_irq *

___mic_request_irq(struct scif_hw_dev *scdev,

		   irqreturn_t (*func)(int irq, void *data),

				       const char *name,

				       void *data, int db)

{

	struct mic_device *mdev = scdev_to_mdev(scdev);



	return mic_request_threaded_irq(mdev, func, NULL, name, data,

					db, MIC_INTR_DB);

}



static void

___mic_free_irq(struct scif_hw_dev *scdev,

		struct mic_irq *cookie, void *data)

{

	struct mic_device *mdev = scdev_to_mdev(scdev);



	return mic_free_irq(mdev, cookie, data);

}



static void ___mic_ack_interrupt(struct scif_hw_dev *scdev, int num)

{

	struct mic_device *mdev = scdev_to_mdev(scdev);



	mdev->ops->intr_workarounds(mdev);

}



static int ___mic_next_db(struct scif_hw_dev *scdev)

{

	struct mic_device *mdev = scdev_to_mdev(scdev);



	return mic_next_db(mdev);

}



static void ___mic_send_intr(struct scif_hw_dev *scdev, int db)

{

	struct mic_device *mdev = scdev_to_mdev(scdev);



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

}



static void __iomem *___mic_ioremap(struct scif_hw_dev *scdev,

				    phys_addr_t pa, size_t len)

{

	struct mic_device *mdev = scdev_to_mdev(scdev);



	return mdev->aper.va + pa;

}



static void ___mic_iounmap(struct scif_hw_dev *scdev, void __iomem *va)

{

	/* nothing to do */

}



static struct scif_hw_ops scif_hw_ops = {

	.request_irq = ___mic_request_irq,

	.free_irq = ___mic_free_irq,

	.ack_interrupt = ___mic_ack_interrupt,

	.next_db = ___mic_next_db,

	.send_intr = ___mic_send_intr,

	.ioremap = ___mic_ioremap,

	.iounmap = ___mic_iounmap,

};



static inline struct mic_device *mbdev_to_mdev(struct mbus_device *mbdev)

{

	return dev_get_drvdata(mbdev->dev.parent);
@@ -127,6 +310,58 @@ void mic_bootparam_init(struct mic_device *mdev) 
	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;

	bootparam->c2h_scif_db = -1;

	bootparam->h2c_scif_db = -1;

}



/**

 * mic_request_dma_chans - Request DMA channels

 * @mdev: pointer to mic_device instance

 *

 * returns number of DMA channels acquired

 */

static int mic_request_dma_chans(struct mic_device *mdev)

{

	dma_cap_mask_t mask;

	struct dma_chan *chan;



	request_module("mic_x100_dma");

	dma_cap_zero(mask);

	dma_cap_set(DMA_MEMCPY, mask);



	do {

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

					   mdev->sdev->parent);

		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);

	return mdev->num_dma_ch;

}



/**

 * mic_free_dma_chans - release DMA channels

 * @mdev: pointer to mic_device instance

 *

 * returns none

 */

static void mic_free_dma_chans(struct mic_device *mdev)

{

	int i = 0;



	for (i = 0; i < mdev->num_dma_ch; i++) {

		dma_release_channel(mdev->dma_ch[i]);

		mdev->dma_ch[i] = NULL;

	}

	mdev->num_dma_ch = 0;

}



/**
@@ -141,6 +376,7 @@ int mic_start(struct mic_device *mdev, const char *buf) 
{

	int rc;

	mutex_lock(&mdev->mic_mutex);

	mic_bootparam_init(mdev);

retry:

	if (MIC_OFFLINE != mdev->state) {

		rc = -EINVAL;
@@ -161,14 +397,22 @@ int mic_start(struct mic_device *mdev, const char *buf) 
		rc = PTR_ERR(mdev->dma_mbdev);

		goto unlock_ret;

	}

	mdev->dma_ch = mic_request_dma_chan(mdev);

	if (!mdev->dma_ch) {

		rc = -ENXIO;

	if (!mic_request_dma_chans(mdev)) {

		rc = -ENODEV;

		goto dma_remove;

	}

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

					   &__mic_dma_ops, &scif_hw_ops,

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

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

					   mdev->dma_ch, mdev->num_dma_ch);

	if (IS_ERR(mdev->scdev)) {

		rc = PTR_ERR(mdev->scdev);

		goto dma_free;

	}

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

	if (rc)

		goto dma_release;

		goto scif_remove;

	mic_smpt_restore(mdev);

	mic_intr_restore(mdev);

	mdev->intr_ops->enable_interrupts(mdev);
@@ -177,8 +421,10 @@ int mic_start(struct mic_device *mdev, const char *buf) 
	mdev->ops->send_firmware_intr(mdev);

	mic_set_state(mdev, MIC_ONLINE);

	goto unlock_ret;

dma_release:

	dma_release_channel(mdev->dma_ch);

scif_remove:

	scif_unregister_device(mdev->scdev);

dma_free:

	mic_free_dma_chans(mdev);

dma_remove:

	mbus_unregister_device(mdev->dma_mbdev);

unlock_ret:
@@ -197,11 +443,9 @@ void mic_stop(struct mic_device *mdev, bool force) 
{

	mutex_lock(&mdev->mic_mutex);

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

		scif_unregister_device(mdev->scdev);

		mic_virtio_reset_devices(mdev);

		if (mdev->dma_ch) {

			dma_release_channel(mdev->dma_ch);

			mdev->dma_ch = NULL;

		}

		mic_free_dma_chans(mdev);

		mbus_unregister_device(mdev->dma_mbdev);

		mic_bootparam_init(mdev);

		mic_reset(mdev);

drivers/misc/mic/host/mic_debugfs.c

+13 −0
Original line number Diff line number Diff line
@@ -214,6 +214,19 @@ static int mic_dp_show(struct seq_file *s, void *pos) 
		   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",

		   bootparam->c2h_scif_db);

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

		   bootparam->h2c_scif_db);

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

		   bootparam->scif_host_dma_addr);

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

		   bootparam->scif_card_dma_addr);





	for (i = sizeof(*bootparam); i < MIC_DP_SIZE;

	     i += mic_total_desc_size(d)) {

drivers/misc/mic/host/mic_device.h

+8 −3
Original line number Diff line number Diff line
@@ -27,7 +27,7 @@ 
#include <linux/irqreturn.h>

#include <linux/dmaengine.h>

#include <linux/mic_bus.h>



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

#include "mic_intr.h"



/* The maximum number of MIC devices supported in a single host system. */
@@ -90,7 +90,9 @@ enum mic_stepping { 
 * @vdev_list: list of virtio devices.

 * @pm_notifier: Handles PM notifications from the OS.

 * @dma_mbdev: MIC BUS DMA device.

 * @dma_ch: DMA channel reserved by this driver for use by virtio devices.

 * @dma_ch - Array of DMA channels

 * @num_dma_ch - Number of DMA channels available

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

 */

struct mic_device {

	struct mic_mw mmio;
@@ -129,7 +131,9 @@ struct mic_device { 
	struct list_head vdev_list;

	struct notifier_block pm_notifier;

	struct mbus_device *dma_mbdev;

	struct dma_chan *dma_ch;

	struct dma_chan *dma_ch[MIC_MAX_DMA_CHAN];

	int num_dma_ch;

	struct scif_hw_dev *scdev;

};



/**
@@ -228,4 +232,5 @@ 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

drivers/misc/mic/host/mic_intr.h

+2 −1
Original line number Diff line number Diff line
@@ -28,8 +28,9 @@ 
 * 3 for virtio network, console and block devices.

 * 1 for card shutdown notifications.

 * 4 for host owned DMA channels.

 * 1 for SCIF

 */

#define MIC_MIN_MSIX 8

#define MIC_MIN_MSIX 9

#define MIC_NUM_OFFSETS 32



/**