Commit a01e28f6 authored by Dasaratharaman Chandramouli's avatar Dasaratharaman Chandramouli Committed by Greg Kroah-Hartman
Browse files

Intel MIC Host Driver Interrupt/SMPT support. 



This patch enables the following features:
a) MSIx, MSI and legacy interrupt support.
b) System Memory Page Table(SMPT) support. SMPT enables system memory
   access from the card. On X100 devices the host can program 32 SMPT
   registers each capable of accessing 16GB of system memory
   address space from X100 devices. The registers can thereby be used
   to access a cumulative 512GB of system memory address space from
   X100 devices at any point in time.

Co-author: Sudeep Dutt <sudeep.dutt@intel.com>
Signed-off-by: default avatarAshutosh Dixit <ashutosh.dixit@intel.com>
Signed-off-by: default avatarCaz Yokoyama <Caz.Yokoyama@intel.com>
Signed-off-by: default avatarDasaratharaman Chandramouli <dasaratharaman.chandramouli@intel.com>
Signed-off-by: default avatarNikhil Rao <nikhil.rao@intel.com>
Signed-off-by: default avatarHarshavardhan R Kharche <harshavardhan.r.kharche@intel.com>
Signed-off-by: default avatarSudeep Dutt <sudeep.dutt@intel.com>
Acked-by: default avatarYaozu (Eddie) Dong <eddie.dong@intel.com>
Reviewed-by: default avatarPeter P Waskiewicz Jr <peter.p.waskiewicz.jr@intel.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent b170d8ce

drivers/misc/mic/host/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -6,3 +6,5 @@ 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

drivers/misc/mic/host/mic_device.h

+21 −0
Original line number Diff line number Diff line
@@ -21,6 +21,10 @@ 
#ifndef _MIC_DEVICE_H_

#define _MIC_DEVICE_H_



#include <linux/idr.h>



#include "mic_intr.h"



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

#define MIC_MAX_NUM_DEVS 256
@@ -53,6 +57,12 @@ enum mic_stepping { 
 * @stepping: Stepping ID.

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

 * @sdev: Device for sysfs entries.

 * @mic_mutex: Mutex for synchronizing access to mic_device.

 * @intr_ops: HW specific interrupt operations.

 * @smpt_ops: Hardware specific SMPT operations.

 * @smpt: MIC SMPT information.

 * @intr_info: H/W specific interrupt information.

 * @irq_info: The OS specific irq information

 */

struct mic_device {

	struct mic_mw mmio;
@@ -63,6 +73,12 @@ struct mic_device { 
	enum mic_stepping stepping;

	const struct attribute_group **attr_group;

	struct device *sdev;

	struct mutex mic_mutex;

	struct mic_hw_intr_ops *intr_ops;

	struct mic_smpt_ops *smpt_ops;

	struct mic_smpt_info *smpt;

	struct mic_intr_info *intr_info;

	struct mic_irq_info irq_info;

};



/**
@@ -71,12 +87,17 @@ struct mic_device { 
 * @mmio_bar: MMIO bar resource number.

 * @read_spad: Read from scratch pad register.

 * @write_spad: Write to scratch pad register.

 * @send_intr: Send an interrupt for a particular doorbell on the card.

 * @ack_interrupt: Hardware specific operations to ack the h/w on

 * receipt of an interrupt.

 */

struct mic_hw_ops {

	u8 aper_bar;

	u8 mmio_bar;

	u32 (*read_spad)(struct mic_device *mdev, unsigned int idx);

	void (*write_spad)(struct mic_device *mdev, unsigned int idx, u32 val);

	void (*send_intr)(struct mic_device *mdev, int doorbell);

	u32 (*ack_interrupt)(struct mic_device *mdev);

};



/**

drivers/misc/mic/host/mic_intr.c

0 → 100644
+628 −0
Original line number Diff line number Diff line 
/*

 * Intel MIC Platform Software Stack (MPSS)

 *

 * Copyright(c) 2013 Intel Corporation.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License, 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.

 *

 * The full GNU General Public License is included in this distribution in

 * the file called "COPYING".

 *

 * Intel MIC Host driver.

 *

 */

#include <linux/pci.h>

#include <linux/interrupt.h>



#include "../common/mic_device.h"

#include "mic_device.h"



/*

 * mic_invoke_callback - Invoke callback functions registered for

 * the corresponding source id.

 *

 * @mdev: pointer to the mic_device instance

 * @idx: The interrupt source id.

 *

 * Returns none.

 */

static inline void mic_invoke_callback(struct mic_device *mdev, int idx)

{

	struct mic_intr_cb *intr_cb;

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

		struct pci_dev, dev);



	spin_lock(&mdev->irq_info.mic_intr_lock);

	list_for_each_entry(intr_cb, &mdev->irq_info.cb_list[idx], list)

		if (intr_cb->func)

			intr_cb->func(pdev->irq, intr_cb->data);

	spin_unlock(&mdev->irq_info.mic_intr_lock);

}



/**

 * mic_interrupt - Generic interrupt handler for

 * MSI and INTx based interrupts.

 */

static irqreturn_t mic_interrupt(int irq, void *dev)

{

	struct mic_device *mdev = dev;

	struct mic_intr_info *info = mdev->intr_info;

	u32 mask;

	int i;



	mask = mdev->ops->ack_interrupt(mdev);

	if (!mask)

		return IRQ_NONE;



	for (i = info->intr_start_idx[MIC_INTR_DB];

			i < info->intr_len[MIC_INTR_DB]; i++)

		if (mask & BIT(i))

			mic_invoke_callback(mdev, i);



	return IRQ_HANDLED;

}



/* Return the interrupt offset from the index. Index is 0 based. */

static u16 mic_map_src_to_offset(struct mic_device *mdev,

		int intr_src, enum mic_intr_type type) {



	if (type >= MIC_NUM_INTR_TYPES)

		return MIC_NUM_OFFSETS;

	if (intr_src >= mdev->intr_info->intr_len[type])

		return MIC_NUM_OFFSETS;



	return mdev->intr_info->intr_start_idx[type] + intr_src;

}



/* Return next available msix_entry. */

static struct msix_entry *mic_get_available_vector(struct mic_device *mdev)

{

	int i;

	struct mic_irq_info *info = &mdev->irq_info;



	for (i = 0; i < info->num_vectors; i++)

		if (!info->mic_msi_map[i])

			return &info->msix_entries[i];

	return NULL;

}



/**

 * mic_register_intr_callback - Register a callback handler for the

 * given source id.

 *

 * @mdev: pointer to the mic_device instance

 * @idx: The source id to be registered.

 * @func: The function to be called when the source id receives

 * the interrupt.

 * @data: Private data of the requester.

 * Return the callback structure that was registered or an

 * appropriate error on failure.

 */

static struct mic_intr_cb *mic_register_intr_callback(struct mic_device *mdev,

			u8 idx, irqreturn_t (*func) (int irq, void *dev),

			void *data)

{

	struct mic_intr_cb *intr_cb;

	unsigned long flags;

	int rc;

	intr_cb = kmalloc(sizeof(struct mic_intr_cb), GFP_KERNEL);



	if (!intr_cb)

		return ERR_PTR(-ENOMEM);



	intr_cb->func = func;

	intr_cb->data = data;

	intr_cb->cb_id = ida_simple_get(&mdev->irq_info.cb_ida,

		0, 0, GFP_KERNEL);

	if (intr_cb->cb_id < 0) {

		rc = intr_cb->cb_id;

		goto ida_fail;

	}



	spin_lock_irqsave(&mdev->irq_info.mic_intr_lock, flags);

	list_add_tail(&intr_cb->list, &mdev->irq_info.cb_list[idx]);

	spin_unlock_irqrestore(&mdev->irq_info.mic_intr_lock, flags);



	return intr_cb;

ida_fail:

	kfree(intr_cb);

	return ERR_PTR(rc);

}



/**

 * mic_unregister_intr_callback - Unregister the callback handler

 * identified by its callback id.

 *

 * @mdev: pointer to the mic_device instance

 * @idx: The callback structure id to be unregistered.

 * Return the source id that was unregistered or MIC_NUM_OFFSETS if no

 * such callback handler was found.

 */

static u8 mic_unregister_intr_callback(struct mic_device *mdev, u32 idx)

{

	struct list_head *pos, *tmp;

	struct mic_intr_cb *intr_cb;

	unsigned long flags;

	int i;



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

		spin_lock_irqsave(&mdev->irq_info.mic_intr_lock, flags);

		list_for_each_safe(pos, tmp, &mdev->irq_info.cb_list[i]) {

			intr_cb = list_entry(pos, struct mic_intr_cb, list);

			if (intr_cb->cb_id == idx) {

				list_del(pos);

				ida_simple_remove(&mdev->irq_info.cb_ida,

					intr_cb->cb_id);

				kfree(intr_cb);

				spin_unlock_irqrestore(

					&mdev->irq_info.mic_intr_lock, flags);

				return i;

			}

		}

		spin_unlock_irqrestore(&mdev->irq_info.mic_intr_lock, flags);

	}

	return MIC_NUM_OFFSETS;

}



/**

 * mic_setup_msix - Initializes MSIx interrupts.

 *

 * @mdev: pointer to mic_device instance

 *

 *

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

 */

static int mic_setup_msix(struct mic_device *mdev, struct pci_dev *pdev)

{

	int rc, i;



	mdev->irq_info.msix_entries = kmalloc(sizeof(struct msix_entry) *

			MIC_MIN_MSIX, GFP_KERNEL);

	if (!mdev->irq_info.msix_entries) {

		rc = -ENOMEM;

		goto err_nomem1;

	}



	for (i = 0; i < MIC_MIN_MSIX; i++)

		mdev->irq_info.msix_entries[i].entry = i;



	rc = pci_enable_msix(pdev, mdev->irq_info.msix_entries,

		MIC_MIN_MSIX);

	if (rc) {

		dev_dbg(&pdev->dev, "Error enabling MSIx. rc = %d\n", rc);

		goto err_enable_msix;

	}



	mdev->irq_info.num_vectors = MIC_MIN_MSIX;

	mdev->irq_info.mic_msi_map = kzalloc((sizeof(u32) *

		mdev->irq_info.num_vectors), GFP_KERNEL);



	if (!mdev->irq_info.mic_msi_map) {

		rc = -ENOMEM;

		goto err_nomem2;

	}



	dev_dbg(mdev->sdev->parent,

		"%d MSIx irqs setup\n", mdev->irq_info.num_vectors);

	return 0;

err_nomem2:

	pci_disable_msix(pdev);

err_enable_msix:

	kfree(mdev->irq_info.msix_entries);

err_nomem1:

	mdev->irq_info.num_vectors = 0;

	return rc;

}



/**

 * mic_setup_callbacks - Initialize data structures needed

 * to handle callbacks.

 *

 * @mdev: pointer to mic_device instance

 */

static int mic_setup_callbacks(struct mic_device *mdev)

{

	int i;



	mdev->irq_info.cb_list = kmalloc(sizeof(struct list_head) *

		MIC_NUM_OFFSETS, GFP_KERNEL);

	if (!mdev->irq_info.cb_list)

		return -ENOMEM;



	for (i = 0; i < MIC_NUM_OFFSETS; i++)

		INIT_LIST_HEAD(&mdev->irq_info.cb_list[i]);

	ida_init(&mdev->irq_info.cb_ida);

	spin_lock_init(&mdev->irq_info.mic_intr_lock);

	return 0;

}



/**

 * mic_release_callbacks - Uninitialize data structures needed

 * to handle callbacks.

 *

 * @mdev: pointer to mic_device instance

 */

static void mic_release_callbacks(struct mic_device *mdev)

{

	unsigned long flags;

	struct list_head *pos, *tmp;

	struct mic_intr_cb *intr_cb;

	int i;



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

		spin_lock_irqsave(&mdev->irq_info.mic_intr_lock, flags);



		if (list_empty(&mdev->irq_info.cb_list[i])) {

			spin_unlock_irqrestore(&mdev->irq_info.mic_intr_lock,

				flags);

			break;

		}



		list_for_each_safe(pos, tmp, &mdev->irq_info.cb_list[i]) {

			intr_cb = list_entry(pos, struct mic_intr_cb, list);

			list_del(pos);

			ida_simple_remove(&mdev->irq_info.cb_ida,

				intr_cb->cb_id);

			kfree(intr_cb);

		}

		spin_unlock_irqrestore(&mdev->irq_info.mic_intr_lock, flags);

	}

	ida_destroy(&mdev->irq_info.cb_ida);

	kfree(mdev->irq_info.cb_list);

}



/**

 * mic_setup_msi - Initializes MSI interrupts.

 *

 * @mdev: pointer to mic_device instance

 * @pdev: PCI device structure

 *

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

 */

static int mic_setup_msi(struct mic_device *mdev, struct pci_dev *pdev)

{

	int rc;



	rc = pci_enable_msi(pdev);

	if (rc) {

		dev_dbg(&pdev->dev, "Error enabling MSI. rc = %d\n", rc);

		return rc;

	}



	mdev->irq_info.num_vectors = 1;

	mdev->irq_info.mic_msi_map = kzalloc((sizeof(u32) *

		mdev->irq_info.num_vectors), GFP_KERNEL);



	if (!mdev->irq_info.mic_msi_map) {

		rc = -ENOMEM;

		goto err_nomem1;

	}



	rc = mic_setup_callbacks(mdev);

	if (rc) {

		dev_err(&pdev->dev, "Error setting up callbacks\n");

		goto err_nomem2;

	}



	rc = request_irq(pdev->irq, mic_interrupt, 0 , "mic-msi", mdev);

	if (rc) {

		dev_err(&pdev->dev, "Error allocating MSI interrupt\n");

		goto err_irq_req_fail;

	}



	dev_dbg(&pdev->dev, "%d MSI irqs setup\n", mdev->irq_info.num_vectors);

	return 0;

err_irq_req_fail:

	mic_release_callbacks(mdev);

err_nomem2:

	kfree(mdev->irq_info.mic_msi_map);

err_nomem1:

	pci_disable_msi(pdev);

	mdev->irq_info.num_vectors = 0;

	return rc;

}



/**

 * mic_setup_intx - Initializes legacy interrupts.

 *

 * @mdev: pointer to mic_device instance

 * @pdev: PCI device structure

 *

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

 */

static int mic_setup_intx(struct mic_device *mdev, struct pci_dev *pdev)

{

	int rc;



	pci_msi_off(pdev);



	/* Enable intx */

	pci_intx(pdev, 1);

	rc = mic_setup_callbacks(mdev);

	if (rc) {

		dev_err(&pdev->dev, "Error setting up callbacks\n");

		goto err_nomem;

	}



	rc = request_irq(pdev->irq, mic_interrupt,

		IRQF_SHARED, "mic-intx", mdev);

	if (rc)

		goto err;



	dev_dbg(&pdev->dev, "intx irq setup\n");

	return 0;

err:

	mic_release_callbacks(mdev);

err_nomem:

	return rc;

}



/**

 * mic_next_db - Retrieve the next doorbell interrupt source id.

 * The id is picked sequentially from the available pool of

 * doorlbell ids.

 *

 * @mdev: pointer to the mic_device instance.

 *

 * Returns the next doorbell interrupt source.

 */

int mic_next_db(struct mic_device *mdev)

{

	int next_db;



	next_db = mdev->irq_info.next_avail_src %

		mdev->intr_info->intr_len[MIC_INTR_DB];

	mdev->irq_info.next_avail_src++;

	return next_db;

}



#define COOKIE_ID_SHIFT 16

#define GET_ENTRY(cookie) ((cookie) & 0xFFFF)

#define GET_OFFSET(cookie) ((cookie) >> COOKIE_ID_SHIFT)

#define MK_COOKIE(x, y) ((x) | (y) << COOKIE_ID_SHIFT)



/**

 * mic_request_irq - request an irq. mic_mutex needs

 * to be held before calling this function.

 *

 * @mdev: pointer to mic_device instance

 * @func: The callback function that handles the interrupt.

 * The function needs to call ack_interrupts

 * (mdev->ops->ack_interrupt(mdev)) when handling the interrupts.

 * @name: The ASCII name of the callee requesting the irq.

 * @data: private data that is returned back when calling the

 * function handler.

 * @intr_src: The source id of the requester. Its the doorbell id

 * for Doorbell interrupts and DMA channel id for DMA interrupts.

 * @type: The type of interrupt. Values defined in mic_intr_type

 *

 * returns: The cookie that is transparent to the caller. Passed

 * back when calling mic_free_irq. An appropriate error code

 * is returned on failure. Caller needs to use IS_ERR(return_val)

 * to check for failure and PTR_ERR(return_val) to obtained the

 * error code.

 *

 */

struct mic_irq *mic_request_irq(struct mic_device *mdev,

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

	const char *name, void *data, int intr_src,

	enum mic_intr_type type)

{

	u16 offset;

	int rc = 0;

	struct msix_entry *msix = NULL;

	unsigned long cookie = 0;

	u16 entry;

	struct mic_intr_cb *intr_cb;

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

		struct pci_dev, dev);



	offset = mic_map_src_to_offset(mdev, intr_src, type);

	if (offset >= MIC_NUM_OFFSETS) {

		dev_err(mdev->sdev->parent,

				"Error mapping index %d to a valid source id.\n",

				intr_src);

		rc = -EINVAL;

		goto err;

	}



	if (mdev->irq_info.num_vectors > 1) {

		msix = mic_get_available_vector(mdev);

		if (!msix) {

			dev_err(mdev->sdev->parent,

			"No MSIx vectors available for use.\n");

			rc = -ENOSPC;

			goto err;

		}



		rc = request_irq(msix->vector, func, 0, name, data);

		if (rc) {

			dev_dbg(mdev->sdev->parent,

				"request irq failed rc = %d\n", rc);

			goto err;

		}

		entry = msix->entry;

		mdev->irq_info.mic_msi_map[entry] |= BIT(offset);

		mdev->intr_ops->program_msi_to_src_map(mdev,

				entry, offset, true);

		cookie = MK_COOKIE(entry, offset);

		dev_dbg(mdev->sdev->parent, "irq: %d assigned for src: %d\n",

			msix->vector, intr_src);

	} else {

		intr_cb = mic_register_intr_callback(mdev,

				offset, func, data);

		if (IS_ERR(intr_cb)) {

			dev_err(mdev->sdev->parent,

			"No available callback entries for use\n");

			rc = PTR_ERR(intr_cb);

			goto err;

		}



		entry = 0;

		if (pci_dev_msi_enabled(pdev)) {

			mdev->irq_info.mic_msi_map[entry] |= (1 << offset);

			mdev->intr_ops->program_msi_to_src_map(mdev,

				entry, offset, true);

		}

		cookie = MK_COOKIE(entry, intr_cb->cb_id);

		dev_dbg(mdev->sdev->parent, "callback %d registered for src: %d\n",

			intr_cb->cb_id, intr_src);

	}

	return (struct mic_irq *)cookie;

err:

	return ERR_PTR(rc);

}



/**

 * mic_free_irq - free irq. mic_mutex

 *  needs to be held before calling this function.

 *

 * @mdev: pointer to mic_device instance

 * @cookie: cookie obtained during a successful call to mic_request_irq

 * @data: private data specified by the calling function during the

 * mic_request_irq

 *

 * returns: none.

 */

void mic_free_irq(struct mic_device *mdev,

	struct mic_irq *cookie, void *data)

{

	u32 offset;

	u32 entry;

	u8 src_id;

	unsigned int irq;

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

		struct pci_dev, dev);



	entry = GET_ENTRY((unsigned long)cookie);

	offset = GET_OFFSET((unsigned long)cookie);

	if (mdev->irq_info.num_vectors > 1) {

		if (entry >= mdev->irq_info.num_vectors) {

			dev_warn(mdev->sdev->parent,

				"entry %d should be < num_irq %d\n",

				entry, mdev->irq_info.num_vectors);

			return;

		}

		irq = mdev->irq_info.msix_entries[entry].vector;

		free_irq(irq, data);

		mdev->irq_info.mic_msi_map[entry] &= ~(BIT(offset));

		mdev->intr_ops->program_msi_to_src_map(mdev,

			entry, offset, false);



		dev_dbg(mdev->sdev->parent, "irq: %d freed\n", irq);

	} else {

		irq = pdev->irq;

		src_id = mic_unregister_intr_callback(mdev, offset);

		if (src_id >= MIC_NUM_OFFSETS) {

			dev_warn(mdev->sdev->parent, "Error unregistering callback\n");

			return;

		}

		if (pci_dev_msi_enabled(pdev)) {

			mdev->irq_info.mic_msi_map[entry] &= ~(BIT(src_id));

			mdev->intr_ops->program_msi_to_src_map(mdev,

				entry, src_id, false);

		}

		dev_dbg(mdev->sdev->parent, "callback %d unregistered for src: %d\n",

			offset, src_id);

	}

}



/**

 * mic_setup_interrupts - Initializes interrupts.

 *

 * @mdev: pointer to mic_device instance

 * @pdev: PCI device structure

 *

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

 */

int mic_setup_interrupts(struct mic_device *mdev, struct pci_dev *pdev)

{

	int rc;



	rc = mic_setup_msix(mdev, pdev);

	if (!rc)

		goto done;



	rc = mic_setup_msi(mdev, pdev);

	if (!rc)

		goto done;



	rc = mic_setup_intx(mdev, pdev);

	if (rc) {

		dev_err(mdev->sdev->parent, "no usable interrupts\n");

		return rc;

	}

done:

	mdev->intr_ops->enable_interrupts(mdev);

	return 0;

}



/**

 * mic_free_interrupts - Frees interrupts setup by mic_setup_interrupts

 *

 * @mdev: pointer to mic_device instance

 * @pdev: PCI device structure

 *

 * returns none.

 */

void mic_free_interrupts(struct mic_device *mdev, struct pci_dev *pdev)

{

	int i;



	mdev->intr_ops->disable_interrupts(mdev);

	if (mdev->irq_info.num_vectors > 1) {

		for (i = 0; i < mdev->irq_info.num_vectors; i++) {

			if (mdev->irq_info.mic_msi_map[i])

				dev_warn(&pdev->dev, "irq %d may still be in use.\n",

					mdev->irq_info.msix_entries[i].vector);

		}

		kfree(mdev->irq_info.mic_msi_map);

		kfree(mdev->irq_info.msix_entries);

		pci_disable_msix(pdev);

	} else {

		if (pci_dev_msi_enabled(pdev)) {

			free_irq(pdev->irq, mdev);

			kfree(mdev->irq_info.mic_msi_map);

			pci_disable_msi(pdev);

		} else {

			free_irq(pdev->irq, mdev);

		}

		mic_release_callbacks(mdev);

	}

}



/**

 * mic_intr_restore - Restore MIC interrupt registers.

 *

 * @mdev: pointer to mic_device instance.

 *

 * Restore the interrupt registers to values previously

 * stored in the SW data structures. mic_mutex needs to

 * be held before calling this function.

 *

 * returns None.

 */

void mic_intr_restore(struct mic_device *mdev)

{

	int entry, offset;

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

		struct pci_dev, dev);



	if (!pci_dev_msi_enabled(pdev))

		return;



	for (entry = 0; entry < mdev->irq_info.num_vectors; entry++) {

		for (offset = 0; offset < MIC_NUM_OFFSETS; offset++) {

			if (mdev->irq_info.mic_msi_map[entry] & BIT(offset))

				mdev->intr_ops->program_msi_to_src_map(mdev,

					entry, offset, true);

		}

	}

}

drivers/misc/mic/host/mic_intr.h

0 → 100644
+137 −0
Original line number Diff line number Diff line 
/*

 * Intel MIC Platform Software Stack (MPSS)

 *

 * Copyright(c) 2013 Intel Corporation.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License, 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.

 *

 * The full GNU General Public License is included in this distribution in

 * the file called "COPYING".

 *

 * Intel MIC Host driver.

 *

 */

#ifndef _MIC_INTR_H_

#define _MIC_INTR_H_



/*

 * The minimum number of msix vectors required for normal operation.

 * 3 for virtio network, console and block devices.

 * 1 for card shutdown notifications.

 */

#define MIC_MIN_MSIX 4

#define MIC_NUM_OFFSETS 32



/**

 * mic_intr_source - The type of source that will generate

 * the interrupt.The number of types needs to be in sync with

 * MIC_NUM_INTR_TYPES

 *

 * MIC_INTR_DB: The source is a doorbell

 * MIC_INTR_DMA: The source is a DMA channel

 * MIC_INTR_ERR: The source is an error interrupt e.g. SBOX ERR

 * MIC_NUM_INTR_TYPES: Total number of interrupt sources.

 */

enum mic_intr_type {

	MIC_INTR_DB = 0,

	MIC_INTR_DMA,

	MIC_INTR_ERR,

	MIC_NUM_INTR_TYPES

};



/**

 * struct mic_intr_info - Contains h/w specific interrupt sources

 * information.

 *

 * @intr_start_idx: Contains the starting indexes of the

 * interrupt types.

 * @intr_len: Contains the length of the interrupt types.

 */

struct mic_intr_info {

	u16 intr_start_idx[MIC_NUM_INTR_TYPES];

	u16 intr_len[MIC_NUM_INTR_TYPES];

};



/**

 * struct mic_irq_info - OS specific irq information

 *

 * @next_avail_src: next available doorbell that can be assigned.

 * @msix_entries: msix entries allocated while setting up MSI-x

 * @mic_msi_map: The MSI/MSI-x mapping information.

 * @num_vectors: The number of MSI/MSI-x vectors that have been allocated.

 * @cb_ida: callback ID allocator to track the callbacks registered.

 * @mic_intr_lock: spinlock to protect the interrupt callback list.

 * @cb_list: Array of callback lists one for each source.

 */

struct mic_irq_info {

	int next_avail_src;

	struct msix_entry *msix_entries;

	u32 *mic_msi_map;

	u16 num_vectors;

	struct ida cb_ida;

	spinlock_t mic_intr_lock;

	struct list_head *cb_list;

};



/**

 * struct mic_intr_cb - Interrupt callback structure.

 *

 * @func: The callback function

 * @data: Private data of the requester.

 * @cb_id: The callback id. Identifies this callback.

 * @list: list head pointing to the next callback structure.

 */

struct mic_intr_cb {

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

	void *data;

	int cb_id;

	struct list_head list;

};



/**

 * struct mic_irq - opaque pointer used as cookie

 */

struct mic_irq;



/* Forward declaration */

struct mic_device;



/**

 * struct mic_hw_intr_ops: MIC HW specific interrupt operations

 * @intr_init: Initialize H/W specific interrupt information.

 * @enable_interrupts: Enable interrupts from the hardware.

 * @disable_interrupts: Disable interrupts from the hardware.

 * @program_msi_to_src_map: Update MSI mapping registers with

 * irq information.

 * @read_msi_to_src_map: Read MSI mapping registers containing

 * irq information.

 */

struct mic_hw_intr_ops {

	void (*intr_init)(struct mic_device *mdev);

	void (*enable_interrupts)(struct mic_device *mdev);

	void (*disable_interrupts)(struct mic_device *mdev);

	void (*program_msi_to_src_map) (struct mic_device *mdev,

			int idx, int intr_src, bool set);

	u32 (*read_msi_to_src_map) (struct mic_device *mdev,

			int idx);

};



int mic_next_db(struct mic_device *mdev);

struct mic_irq *mic_request_irq(struct mic_device *mdev,

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

	const char *name, void *data, int intr_src,

	enum mic_intr_type type);



void mic_free_irq(struct mic_device *mdev,

		struct mic_irq *cookie, void *data);

int mic_setup_interrupts(struct mic_device *mdev, struct pci_dev *pdev);

void mic_free_interrupts(struct mic_device *mdev, struct pci_dev *pdev);

void mic_intr_restore(struct mic_device *mdev);

#endif

drivers/misc/mic/host/mic_main.c

+24 −2
Original line number Diff line number Diff line
@@ -23,13 +23,13 @@ 
 * 2) Enable per vring interrupt support.

 */

#include <linux/fs.h>

#include <linux/idr.h>

#include <linux/module.h>

#include <linux/pci.h>



#include "../common/mic_device.h"

#include "mic_device.h"

#include "mic_x100.h"

#include "mic_smpt.h"



static const char mic_driver_name[] = "mic";
@@ -75,6 +75,8 @@ static void mic_ops_init(struct mic_device *mdev) 
	switch (mdev->family) {

	case MIC_FAMILY_X100:

		mdev->ops = &mic_x100_ops;

		mdev->intr_ops = &mic_x100_intr_ops;

		mdev->smpt_ops = &mic_x100_smpt_ops;

		break;

	default:

		break;
@@ -132,6 +134,8 @@ mic_device_init(struct mic_device *mdev, struct pci_dev *pdev) 
	mdev->stepping = pdev->revision;

	mic_ops_init(mdev);

	mic_sysfs_init(mdev);

	mutex_init(&mdev->mic_mutex);

	mdev->irq_info.next_avail_src = 0;

}



/**
@@ -201,6 +205,18 @@ static int mic_probe(struct pci_dev *pdev, 
		goto unmap_mmio;

	}



	mdev->intr_ops->intr_init(mdev);

	rc = mic_setup_interrupts(mdev, pdev);

	if (rc) {

		dev_err(&pdev->dev, "mic_setup_interrupts failed %d\n", rc);

		goto unmap_aper;

	}

	rc = mic_smpt_init(mdev);

	if (rc) {

		dev_err(&pdev->dev, "smpt_init failed %d\n", rc);

		goto free_interrupts;

	}



	pci_set_drvdata(pdev, mdev);



	mdev->sdev = device_create_with_groups(g_mic_class, &pdev->dev,
@@ -210,9 +226,13 @@ static int mic_probe(struct pci_dev *pdev, 
		rc = PTR_ERR(mdev->sdev);

		dev_err(&pdev->dev,

			"device_create_with_groups failed rc %d\n", rc);

		goto unmap_aper;

		goto smpt_uninit;

	}

	return 0;

smpt_uninit:

	mic_smpt_uninit(mdev);

free_interrupts:

	mic_free_interrupts(mdev, pdev);

unmap_aper:

	iounmap(mdev->aper.va);

unmap_mmio:
@@ -246,6 +266,8 @@ static void mic_remove(struct pci_dev *pdev) 
		return;



	device_destroy(g_mic_class, MKDEV(MAJOR(g_mic_devno), mdev->id));

	mic_smpt_uninit(mdev);

	mic_free_interrupts(mdev, pdev);

	iounmap(mdev->mmio.va);

	iounmap(mdev->aper.va);

	pci_release_regions(pdev);

CRA Git | Maintained and supported by SUSTech CRA and CCSE