[deliverable/linux.git] / drivers / mtd / nand / denali_pci.c

/*
 * NAND Flash Controller Device Driver
 * Copyright © 2009-2010, Intel Corporation and its suppliers.
 *
 * 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 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.
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/slab.h>

#include "denali.h"

#define DENALI_NAND_NAME    "denali-nand-pci"

/* List of platforms this NAND controller has be integrated into */
static const struct pci_device_id denali_pci_ids[] = {
	{ PCI_VDEVICE(INTEL, 0x0701), INTEL_CE4100 },
	{ PCI_VDEVICE(INTEL, 0x0809), INTEL_MRST },
	{ /* end: all zeroes */ }
};
MODULE_DEVICE_TABLE(pci, denali_pci_ids);

static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
{
	int ret = -ENODEV;
	resource_size_t csr_base, mem_base;
	unsigned long csr_len, mem_len;
	struct denali_nand_info *denali;

	denali = kzalloc(sizeof(*denali), GFP_KERNEL);
	if (!denali)
		return -ENOMEM;

	ret = pci_enable_device(dev);
	if (ret) {
		pr_err("Spectra: pci_enable_device failed.\n");
		goto failed_alloc_memery;
	}

	if (id->driver_data == INTEL_CE4100) {
		denali->platform = INTEL_CE4100;
		mem_base = pci_resource_start(dev, 0);
		mem_len = pci_resource_len(dev, 1);
		csr_base = pci_resource_start(dev, 1);
		csr_len = pci_resource_len(dev, 1);
	} else {
		denali->platform = INTEL_MRST;
		csr_base = pci_resource_start(dev, 0);
		csr_len = pci_resource_len(dev, 0);
		mem_base = pci_resource_start(dev, 1);
		mem_len = pci_resource_len(dev, 1);
		if (!mem_len) {
			mem_base = csr_base + csr_len;
			mem_len = csr_len;
		}
	}

	pci_set_master(dev);
	denali->dev = &dev->dev;
	denali->irq = dev->irq;

	ret = pci_request_regions(dev, DENALI_NAND_NAME);
	if (ret) {
		pr_err("Spectra: Unable to request memory regions\n");
		goto failed_enable_dev;
	}

	denali->flash_reg = ioremap_nocache(csr_base, csr_len);
	if (!denali->flash_reg) {
		pr_err("Spectra: Unable to remap memory region\n");
		ret = -ENOMEM;
		goto failed_req_regions;
	}

	denali->flash_mem = ioremap_nocache(mem_base, mem_len);
	if (!denali->flash_mem) {
		pr_err("Spectra: ioremap_nocache failed!");
		ret = -ENOMEM;
		goto failed_remap_reg;
	}

	ret = denali_init(denali);
	if (ret)
		goto failed_remap_mem;

	pci_set_drvdata(dev, denali);

	return 0;

failed_remap_mem:
	iounmap(denali->flash_mem);
failed_remap_reg:
	iounmap(denali->flash_reg);
failed_req_regions:
	pci_release_regions(dev);
failed_enable_dev:
	pci_disable_device(dev);
failed_alloc_memery:
	kfree(denali);

	return ret;
}

/* driver exit point */
static void denali_pci_remove(struct pci_dev *dev)
{
	struct denali_nand_info *denali = pci_get_drvdata(dev);

	denali_remove(denali);
	iounmap(denali->flash_reg);
	iounmap(denali->flash_mem);
	pci_release_regions(dev);
	pci_disable_device(dev);
	kfree(denali);
}

static struct pci_driver denali_pci_driver = {
	.name = DENALI_NAND_NAME,
	.id_table = denali_pci_ids,
	.probe = denali_pci_probe,
	.remove = denali_pci_remove,
};

static int denali_init_pci(void)
{
	return pci_register_driver(&denali_pci_driver);
}
module_init(denali_init_pci);

static void denali_exit_pci(void)
{
	pci_unregister_driver(&denali_pci_driver);
}
module_exit(denali_exit_pci);
Commit	Line	Data
2a0a288e DN	1	/*
	2	* NAND Flash Controller Device Driver
	3	* Copyright © 2009-2010, Intel Corporation and its suppliers.
	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 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	#include <linux/kernel.h>
	15	#include <linux/module.h>
	16	#include <linux/pci.h>
	17	#include <linux/slab.h>
	18
	19	#include "denali.h"
	20
	21	#define DENALI_NAND_NAME "denali-nand-pci"
	22
	23	/* List of platforms this NAND controller has be integrated into */
94f7039a	24	static const struct pci_device_id denali_pci_ids[] = {
2a0a288e DN	25	{ PCI_VDEVICE(INTEL, 0x0701), INTEL_CE4100 },
	26	{ PCI_VDEVICE(INTEL, 0x0809), INTEL_MRST },
	27	{ /* end: all zeroes */ }
	28	};
	29	MODULE_DEVICE_TABLE(pci, denali_pci_ids);
	30
	31	static int denali_pci_probe(struct pci_dev dev, const struct pci_device_id id)
	32	{
	33	int ret = -ENODEV;
	34	resource_size_t csr_base, mem_base;
	35	unsigned long csr_len, mem_len;
	36	struct denali_nand_info *denali;
	37
	38	denali = kzalloc(sizeof(*denali), GFP_KERNEL);
	39	if (!denali)
	40	return -ENOMEM;
	41
	42	ret = pci_enable_device(dev);
	43	if (ret) {
	44	pr_err("Spectra: pci_enable_device failed.\n");
	45	goto failed_alloc_memery;
	46	}
	47
	48	if (id->driver_data == INTEL_CE4100) {
	49	denali->platform = INTEL_CE4100;
	50	mem_base = pci_resource_start(dev, 0);
	51	mem_len = pci_resource_len(dev, 1);
	52	csr_base = pci_resource_start(dev, 1);
	53	csr_len = pci_resource_len(dev, 1);
	54	} else {
	55	denali->platform = INTEL_MRST;
	56	csr_base = pci_resource_start(dev, 0);
	57	csr_len = pci_resource_len(dev, 0);
	58	mem_base = pci_resource_start(dev, 1);
	59	mem_len = pci_resource_len(dev, 1);
	60	if (!mem_len) {
	61	mem_base = csr_base + csr_len;
	62	mem_len = csr_len;
	63	}
	64	}
	65
	66	pci_set_master(dev);
	67	denali->dev = &dev->dev;
	68	denali->irq = dev->irq;
	69
	70	ret = pci_request_regions(dev, DENALI_NAND_NAME);
	71	if (ret) {
	72	pr_err("Spectra: Unable to request memory regions\n");
	73	goto failed_enable_dev;
	74	}
	75
	76	denali->flash_reg = ioremap_nocache(csr_base, csr_len);
	77	if (!denali->flash_reg) {
	78	pr_err("Spectra: Unable to remap memory region\n");
	79	ret = -ENOMEM;
	80	goto failed_req_regions;
	81	}
	82
	83	denali->flash_mem = ioremap_nocache(mem_base, mem_len);
	84	if (!denali->flash_mem) {
	85	pr_err("Spectra: ioremap_nocache failed!");
	86	ret = -ENOMEM;
	87	goto failed_remap_reg;
	88	}
89
90	ret = denali_init(denali);
91	if (ret)
92	goto failed_remap_mem;
93
94	pci_set_drvdata(dev, denali);
95
96	return 0;
97
98	failed_remap_mem:
99	iounmap(denali->flash_mem);
100	failed_remap_reg:
101	iounmap(denali->flash_reg);
102	failed_req_regions:
103	pci_release_regions(dev);
104	failed_enable_dev:
105	pci_disable_device(dev);
106	failed_alloc_memery:
107	kfree(denali);
108
109	return ret;
110	}
111
112	/* driver exit point */
113	static void denali_pci_remove(struct pci_dev *dev)
114	{
115	struct denali_nand_info *denali = pci_get_drvdata(dev);
116
117	denali_remove(denali);
118	iounmap(denali->flash_reg);
119	iounmap(denali->flash_mem);
120	pci_release_regions(dev);
121	pci_disable_device(dev);
2a0a288e DN	122	kfree(denali);
	123	}
	124
	125	static struct pci_driver denali_pci_driver = {
	126	.name = DENALI_NAND_NAME,
	127	.id_table = denali_pci_ids,
	128	.probe = denali_pci_probe,
	129	.remove = denali_pci_remove,
	130	};
	131
06f25510	132	static int denali_init_pci(void)
2a0a288e	133	{
2a0a288e DN	134	return pci_register_driver(&denali_pci_driver);
	135	}
	136	module_init(denali_init_pci);
	137
810b7e06	138	static void denali_exit_pci(void)
2a0a288e DN	139	{
	140	pci_unregister_driver(&denali_pci_driver);
	141	}
	142	module_exit(denali_exit_pci);