Intel MIC Host Driver Interrupt/SMPT support. (a01e28f6) · Commits · e / devices / android_kernel_xiaomi_markw

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