mtd: denali: split the generic driver and PCI layer

The Denali controller can also be found in SoC devices attached to a simple bus. Move the PCI specific parts into denali_pci so that we can add a denali_dt that uses the same driver but for a device tree driver instead of a PCI based device. Signed-off-by: Jamie Iles <jamie@jamieiles.com> Signed-off-by: Artem Bityutskiy <artem.bityutskiy@linux.intel.com>
author: Dinh Nguyen <dinguyen@altera.com> 2012-09-27 12:58:05 -0400
committer: Artem Bityutskiy <artem.bityutskiy@linux.intel.com> 2012-11-15 08:37:46 -0500
commit: 2a0a288ec258bd38d8855fad9419aeb45b7e8499 (patch)
tree: f726010165435c55d7b54936fa2521391b05a89b /drivers/mtd/nand/denali_pci.c
parent: 30fad64325ba368ffe1f92bd37f4b96c1fa4da83 (diff)
1 files changed, 144 insertions, 0 deletions
diff --git a/drivers/mtd/nand/denali_pci.c b/drivers/mtd/nand/denali_pci.c
new file mode 100644
index 000000000000..ea074e6c7622
--- /dev/null
+++ b/drivers/mtd/nand/denali_pci.c
@@ -0,0 +1,144 @@
+/*
+ * 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 DEFINE_PCI_DEVICE_TABLE(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);
+        pci_set_drvdata(dev, NULL);
+        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 __devinit denali_init_pci(void)
+{
+        pr_info("Spectra MTD driver built on %s @ %s\n", __DATE__, __TIME__);
+        return pci_register_driver(&denali_pci_driver);
+}
+module_init(denali_init_pci);
+static void __devexit denali_exit_pci(void)
+{
+        pci_unregister_driver(&denali_pci_driver);
+}
+module_exit(denali_exit_pci);
author	Dinh Nguyen <dinguyen@altera.com>	2012-09-27 12:58:05 -0400
committer	Artem Bityutskiy <artem.bityutskiy@linux.intel.com>	2012-11-15 08:37:46 -0500
commit	2a0a288ec258bd38d8855fad9419aeb45b7e8499 (patch)
tree	f726010165435c55d7b54936fa2521391b05a89b /drivers/mtd/nand/denali_pci.c
parent	30fad64325ba368ffe1f92bd37f4b96c1fa4da83 (diff)

diff --git a/drivers/mtd/nand/denali_pci.c b/drivers/mtd/nand/denali_pci.c new file mode 100644 index 000000000000..ea074e6c7622 --- /dev/null +++ b/drivers/mtd/nand/denali_pci.c
@@ -0,0 +1,144 @@
	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 */
	24	static DEFINE_PCI_DEVICE_TABLE(denali_pci_ids) = {
	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);
	122	pci_set_drvdata(dev, NULL);
	123	kfree(denali);
	124	}
	125
	126	static struct pci_driver denali_pci_driver = {
	127	.name = DENALI_NAND_NAME,
	128	.id_table = denali_pci_ids,
	129	.probe = denali_pci_probe,
	130	.remove = denali_pci_remove,
	131	};
	132
	133	static int __devinit denali_init_pci(void)
	134	{
	135	pr_info("Spectra MTD driver built on %s @ %s\n", __DATE__, __TIME__);
	136	return pci_register_driver(&denali_pci_driver);
	137	}
	138	module_init(denali_init_pci);
	139
	140	static void __devexit denali_exit_pci(void)
	141	{
	142	pci_unregister_driver(&denali_pci_driver);
	143	}
	144	module_exit(denali_exit_pci);