Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/drivers/mtd/nand/denali_pci.c

  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 const struct pci_device_id 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         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 
132 static int denali_init_pci(void)
133 {
134         return pci_register_driver(&denali_pci_driver);
135 }
136 module_init(denali_init_pci);
137 
138 static void denali_exit_pci(void)
139 {
140         pci_unregister_driver(&denali_pci_driver);
141 }
142 module_exit(denali_exit_pci);
143 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us