[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / dma / ioat / pci.c

/*
 * Intel I/OAT DMA Linux driver
 * Copyright(c) 2007 - 2009 Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions 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.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * The full GNU General Public License is included in this distribution in
 * the file called "COPYING".
 *
 */

/*
 * This driver supports an Intel I/OAT DMA engine, which does asynchronous
 * copy operations.
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/interrupt.h>
#include <linux/dca.h>
#include <linux/slab.h>
#include "dma.h"
#include "dma_v2.h"
#include "registers.h"
#include "hw.h"

MODULE_VERSION(IOAT_DMA_VERSION);
MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("Intel Corporation");

static struct pci_device_id ioat_pci_tbl[] = {
	/* I/OAT v1 platforms */
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_CNB)  },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SCNB) },
	{ PCI_VDEVICE(UNISYS, PCI_DEVICE_ID_UNISYS_DMA_DIRECTOR) },

	/* I/OAT v2 platforms */
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB) },

	/* I/OAT v3 platforms */
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG0) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG1) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG2) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG3) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG4) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG5) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG6) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG7) },

	/* I/OAT v3.2 platforms */
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF0) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF1) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF2) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF3) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF4) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF5) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF6) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF7) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF8) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF9) },

	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB0) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB1) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB2) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB3) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB4) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB5) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB6) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB7) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB8) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB9) },

	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB0) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB1) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB2) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB3) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB4) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB5) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB6) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB7) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB8) },
	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB9) },

	{ 0, }
};
MODULE_DEVICE_TABLE(pci, ioat_pci_tbl);

static int ioat_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id);
static void ioat_remove(struct pci_dev *pdev);

static int ioat_dca_enabled = 1;
module_param(ioat_dca_enabled, int, 0644);
MODULE_PARM_DESC(ioat_dca_enabled, "control support of dca service (default: 1)");

struct kmem_cache *ioat2_cache;

#define DRV_NAME "ioatdma"

static struct pci_driver ioat_pci_driver = {
	.name		= DRV_NAME,
	.id_table	= ioat_pci_tbl,
	.probe		= ioat_pci_probe,
	.remove		= ioat_remove,
};

static struct ioatdma_device *
alloc_ioatdma(struct pci_dev *pdev, void __iomem *iobase)
{
	struct device *dev = &pdev->dev;
	struct ioatdma_device *d = devm_kzalloc(dev, sizeof(*d), GFP_KERNEL);

	if (!d)
		return NULL;
	d->pdev = pdev;
	d->reg_base = iobase;
	return d;
}

static int ioat_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
	void __iomem * const *iomap;
	struct device *dev = &pdev->dev;
	struct ioatdma_device *device;
	int err;

	err = pcim_enable_device(pdev);
	if (err)
		return err;

	err = pcim_iomap_regions(pdev, 1 << IOAT_MMIO_BAR, DRV_NAME);
	if (err)
		return err;
	iomap = pcim_iomap_table(pdev);
	if (!iomap)
		return -ENOMEM;

	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
	if (err)
		err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
	if (err)
		return err;

	err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
	if (err)
		err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
	if (err)
		return err;

	device = alloc_ioatdma(pdev, iomap[IOAT_MMIO_BAR]);
	if (!device)
		return -ENOMEM;
	pci_set_master(pdev);
	pci_set_drvdata(pdev, device);

	device->version = readb(device->reg_base + IOAT_VER_OFFSET);
	if (device->version == IOAT_VER_1_2)
		err = ioat1_dma_probe(device, ioat_dca_enabled);
	else if (device->version == IOAT_VER_2_0)
		err = ioat2_dma_probe(device, ioat_dca_enabled);
	else if (device->version >= IOAT_VER_3_0)
		err = ioat3_dma_probe(device, ioat_dca_enabled);
	else
		return -ENODEV;

	if (err) {
		dev_err(dev, "Intel(R) I/OAT DMA Engine init failed\n");
		return -ENODEV;
	}

	return 0;
}

static void ioat_remove(struct pci_dev *pdev)
{
	struct ioatdma_device *device = pci_get_drvdata(pdev);

	if (!device)
		return;

	dev_err(&pdev->dev, "Removing dma and dca services\n");
	if (device->dca) {
		unregister_dca_provider(device->dca, &pdev->dev);
		free_dca_provider(device->dca);
		device->dca = NULL;
	}
	ioat_dma_remove(device);
}

static int __init ioat_init_module(void)
{
	int err;

	pr_info("%s: Intel(R) QuickData Technology Driver %s\n",
		DRV_NAME, IOAT_DMA_VERSION);

	ioat2_cache = kmem_cache_create("ioat2", sizeof(struct ioat_ring_ent),
					0, SLAB_HWCACHE_ALIGN, NULL);
	if (!ioat2_cache)
		return -ENOMEM;

	err = pci_register_driver(&ioat_pci_driver);
	if (err)
		kmem_cache_destroy(ioat2_cache);

	return err;
}
module_init(ioat_init_module);

static void __exit ioat_exit_module(void)
{
	pci_unregister_driver(&ioat_pci_driver);
	kmem_cache_destroy(ioat2_cache);
}
module_exit(ioat_exit_module);
Commit	Line	Data
8ab89567 SN	1	/*
8ab89567 SN	2	* Intel I/OAT DMA Linux driver
211a22ce	3	* Copyright(c) 2007 - 2009 Intel Corporation.
8ab89567 SN	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms and conditions of the GNU General Public License,
	7	* version 2, as published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	* You should have received a copy of the GNU General Public License along with
	15	* this program; if not, write to the Free Software Foundation, Inc.,
	16	* 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
	17	*
	18	* The full GNU General Public License is included in this distribution in
	19	* the file called "COPYING".
	20	*
	21	*/
	22
	23	/*
	24	* This driver supports an Intel I/OAT DMA engine, which does asynchronous
	25	* copy operations.
	26	*/
	27
	28	#include <linux/init.h>
	29	#include <linux/module.h>
	30	#include <linux/pci.h>
	31	#include <linux/interrupt.h>
2ed6dc34	32	#include <linux/dca.h>
5a0e3ad6	33	#include <linux/slab.h>
584ec227	34	#include "dma.h"
5cbafa65	35	#include "dma_v2.h"
584ec227 DW	36	#include "registers.h"
584ec227 DW	37	#include "hw.h"
8ab89567	38
5149fd01	39	MODULE_VERSION(IOAT_DMA_VERSION);
bf40a686	40	MODULE_LICENSE("Dual BSD/GPL");
8ab89567 SN	41	MODULE_AUTHOR("Intel Corporation");
	42
	43	static struct pci_device_id ioat_pci_tbl[] = {
7bb67c14	44	/* I/OAT v1 platforms */
a6417dd5 RD	45	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT) },
	46	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_CNB) },
	47	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SCNB) },
	48	{ PCI_VDEVICE(UNISYS, PCI_DEVICE_ID_UNISYS_DMA_DIRECTOR) },
7bb67c14 SN	49
7bb67c14 SN	50	/* I/OAT v2 platforms */
a6417dd5	51	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB) },
7f1b358a MS	52
7f1b358a MS	53	/* I/OAT v3 platforms */
a6417dd5 RD	54	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG0) },
	55	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG1) },
	56	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG2) },
	57	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG3) },
	58	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG4) },
	59	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG5) },
	60	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG6) },
	61	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG7) },
b265b11f TP	62
b265b11f TP	63	/* I/OAT v3.2 platforms */
a6417dd5 RD	64	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF0) },
	65	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF1) },
	66	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF2) },
	67	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF3) },
	68	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF4) },
	69	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF5) },
	70	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF6) },
	71	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF7) },
	72	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF8) },
	73	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_JSF9) },
b265b11f	74
3baef940 DJ	75	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB0) },
	76	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB1) },
	77	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB2) },
	78	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB3) },
	79	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB4) },
	80	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB5) },
	81	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB6) },
	82	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB7) },
	83	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB8) },
	84	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB9) },
	85
8eb4da28 DJ	86	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB0) },
	87	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB1) },
	88	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB2) },
	89	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB3) },
	90	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB4) },
	91	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB5) },
	92	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB6) },
	93	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB7) },
	94	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB8) },
	95	{ PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_IOAT_IVB9) },
	96
8ab89567 SN	97	{ 0, }
8ab89567 SN	98	};
6506cbca	99	MODULE_DEVICE_TABLE(pci, ioat_pci_tbl);
8ab89567	100
4bf27b8b GKH	101	static int ioat_pci_probe(struct pci_dev pdev, const struct pci_device_id id);
4bf27b8b GKH	102	static void ioat_remove(struct pci_dev *pdev);
8ab89567	103
2ed6dc34 SN	104	static int ioat_dca_enabled = 1;
	105	module_param(ioat_dca_enabled, int, 0644);
	106	MODULE_PARM_DESC(ioat_dca_enabled, "control support of dca service (default: 1)");
	107
162b96e6 DW	108	struct kmem_cache *ioat2_cache;
162b96e6 DW	109
e6c0b69a DW	110	#define DRV_NAME "ioatdma"
e6c0b69a DW	111
7df7cf06	112	static struct pci_driver ioat_pci_driver = {
e6c0b69a	113	.name = DRV_NAME,
8ab89567	114	.id_table = ioat_pci_tbl,
f2427e27	115	.probe = ioat_pci_probe,
a7d6e3ec	116	.remove = ioat_remove,
8ab89567 SN	117	};
8ab89567 SN	118
f2427e27 DW	119	static struct ioatdma_device *
	120	alloc_ioatdma(struct pci_dev pdev, void __iomem iobase)
	121	{
	122	struct device *dev = &pdev->dev;
	123	struct ioatdma_device d = devm_kzalloc(dev, sizeof(d), GFP_KERNEL);
	124
	125	if (!d)
	126	return NULL;
	127	d->pdev = pdev;
	128	d->reg_base = iobase;
	129	return d;
	130	}
	131
4bf27b8b	132	static int ioat_pci_probe(struct pci_dev pdev, const struct pci_device_id id)
8ab89567	133	{
e6c0b69a	134	void __iomem * const *iomap;
e6c0b69a	135	struct device *dev = &pdev->dev;
f2427e27	136	struct ioatdma_device *device;
8ab89567 SN	137	int err;
8ab89567 SN	138
e6c0b69a	139	err = pcim_enable_device(pdev);
8ab89567	140	if (err)
e6c0b69a	141	return err;
8ab89567	142
e6c0b69a	143	err = pcim_iomap_regions(pdev, 1 << IOAT_MMIO_BAR, DRV_NAME);
8ab89567	144	if (err)
e6c0b69a DW	145	return err;
	146	iomap = pcim_iomap_table(pdev);
	147	if (!iomap)
	148	return -ENOMEM;
8ab89567	149
6a35528a	150	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
8ab89567	151	if (err)
284901a9	152	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
8ab89567	153	if (err)
e6c0b69a	154	return err;
8ab89567	155
6a35528a	156	err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
8ab89567	157	if (err)
284901a9	158	err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
8ab89567	159	if (err)
e6c0b69a DW	160	return err;
e6c0b69a DW	161
f2427e27 DW	162	device = alloc_ioatdma(pdev, iomap[IOAT_MMIO_BAR]);
	163	if (!device)
	164	return -ENOMEM;
c86e1401	165	pci_set_master(pdev);
f2427e27 DW	166	pci_set_drvdata(pdev, device);
	167
	168	device->version = readb(device->reg_base + IOAT_VER_OFFSET);
	169	if (device->version == IOAT_VER_1_2)
	170	err = ioat1_dma_probe(device, ioat_dca_enabled);
	171	else if (device->version == IOAT_VER_2_0)
	172	err = ioat2_dma_probe(device, ioat_dca_enabled);
	173	else if (device->version >= IOAT_VER_3_0)
	174	err = ioat3_dma_probe(device, ioat_dca_enabled);
	175	else
e6c0b69a	176	return -ENODEV;
4fac7fa5	177
f2427e27	178	if (err) {
e6c0b69a DW	179	dev_err(dev, "Intel(R) I/OAT DMA Engine init failed\n");
	180	return -ENODEV;
	181	}
8ab89567 SN	182
8ab89567 SN	183	return 0;
8ab89567 SN	184	}
8ab89567 SN	185
4bf27b8b	186	static void ioat_remove(struct pci_dev *pdev)
8ab89567	187	{
f2427e27 DW	188	struct ioatdma_device *device = pci_get_drvdata(pdev);
	189
	190	if (!device)
	191	return;
8ab89567	192
4fac7fa5 DW	193	dev_err(&pdev->dev, "Removing dma and dca services\n");
4fac7fa5 DW	194	if (device->dca) {
1a5aeeec	195	unregister_dca_provider(device->dca, &pdev->dev);
4fac7fa5 DW	196	free_dca_provider(device->dca);
	197	device->dca = NULL;
	198	}
f2427e27	199	ioat_dma_remove(device);
8ab89567	200	}
8ab89567 SN	201
	202	static int __init ioat_init_module(void)
	203	{
162b96e6 DW	204	int err;
162b96e6 DW	205
5669e31c DW	206	pr_info("%s: Intel(R) QuickData Technology Driver %s\n",
	207	DRV_NAME, IOAT_DMA_VERSION);
	208
162b96e6 DW	209	ioat2_cache = kmem_cache_create("ioat2", sizeof(struct ioat_ring_ent),
	210	0, SLAB_HWCACHE_ALIGN, NULL);
	211	if (!ioat2_cache)
	212	return -ENOMEM;
	213
	214	err = pci_register_driver(&ioat_pci_driver);
	215	if (err)
	216	kmem_cache_destroy(ioat2_cache);
	217
	218	return err;
8ab89567 SN	219	}
	220	module_init(ioat_init_module);
	221
	222	static void __exit ioat_exit_module(void)
	223	{
7df7cf06	224	pci_unregister_driver(&ioat_pci_driver);
162b96e6	225	kmem_cache_destroy(ioat2_cache);
8ab89567 SN	226	}
8ab89567 SN	227	module_exit(ioat_exit_module);