0d3a966d2b
Introduce some macros and helpers to avoid magic numbers and
rename macros/functions for clarification.
- We see '| 2' in several places. This means Data Cycle in MAP11 mode.
The Denali User's Guide says bit[1:0] of MAP11 is like follows:
b'00 = Command Cycle
b'01 = Address Cycle
b'10 = Data Cycle
So, this commit added DENALI_MAP11_{CMD,ADDR,DATA} macros.
- We see 'denali->flash_mem + 0x10' in several places, but 0x10 is a
magic number. Actually, this accesses the data port of the Host
Data/Command Interface. So, this commit added DENALI_HOST_DATA.
On the other hand, 'denali->flash_mem' gets access to the address
port, so DENALI_HOST_ADDR was also added.
- We see 'index_addr(denali, cmd, 0x1)' in denali_erase(), but 0x1
is a magic number. 0x1 means the erase operation. Replace 0x1
with DENALI_ERASE.
- Rename index_addr() to denali_host_write() for clarification
- Denali User's Guide says MAP{00,01,10,11} for access mode. Match
the macros with terminology in the IP document.
- Rename struct members as follows:
flash_bank -> active_bank (currently selected bank)
flash_reg -> reg (base address of registers)
flash_mem -> host (base address of host interface)
devnum -> devs_per_cs (devices connected in parallel)
bbtskipbytes -> oob_skip_bytes (number of bytes to skip in OOB)
Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Signed-off-by: Boris Brezillon <boris.brezillon@free-electrons.com>
127 lines
3.2 KiB
C
127 lines
3.2 KiB
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 "denali.h"
|
|
|
|
#define DENALI_NAND_NAME "denali-nand-pci"
|
|
|
|
#define INTEL_CE4100 1
|
|
#define INTEL_MRST 2
|
|
|
|
/* 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);
|
|
|
|
NAND_ECC_CAPS_SINGLE(denali_pci_ecc_caps, denali_calc_ecc_bytes, 512, 8, 15);
|
|
|
|
static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
|
|
{
|
|
int ret;
|
|
resource_size_t csr_base, mem_base;
|
|
unsigned long csr_len, mem_len;
|
|
struct denali_nand_info *denali;
|
|
|
|
denali = devm_kzalloc(&dev->dev, sizeof(*denali), GFP_KERNEL);
|
|
if (!denali)
|
|
return -ENOMEM;
|
|
|
|
ret = pcim_enable_device(dev);
|
|
if (ret) {
|
|
dev_err(&dev->dev, "Spectra: pci_enable_device failed.\n");
|
|
return ret;
|
|
}
|
|
|
|
if (id->driver_data == 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 {
|
|
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;
|
|
denali->ecc_caps = &denali_pci_ecc_caps;
|
|
denali->nand.ecc.options |= NAND_ECC_MAXIMIZE;
|
|
denali->clk_x_rate = 200000000; /* 200 MHz */
|
|
|
|
ret = pci_request_regions(dev, DENALI_NAND_NAME);
|
|
if (ret) {
|
|
dev_err(&dev->dev, "Spectra: Unable to request memory regions\n");
|
|
return ret;
|
|
}
|
|
|
|
denali->reg = ioremap_nocache(csr_base, csr_len);
|
|
if (!denali->reg) {
|
|
dev_err(&dev->dev, "Spectra: Unable to remap memory region\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
denali->host = ioremap_nocache(mem_base, mem_len);
|
|
if (!denali->host) {
|
|
dev_err(&dev->dev, "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->host);
|
|
failed_remap_reg:
|
|
iounmap(denali->reg);
|
|
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->reg);
|
|
iounmap(denali->host);
|
|
}
|
|
|
|
static struct pci_driver denali_pci_driver = {
|
|
.name = DENALI_NAND_NAME,
|
|
.id_table = denali_pci_ids,
|
|
.probe = denali_pci_probe,
|
|
.remove = denali_pci_remove,
|
|
};
|
|
|
|
module_pci_driver(denali_pci_driver);
|