mtd: nand: Add driver for Ricoh xD/SmartMedia reader

This adds a driver for Ricoh R5C852 xD card reader.

This reader is a part of larger mulifunction chip
and found at least in R5C832

Driver is complete, but bewere of the fact that some
(probably only type M) xD cards are 'fake' which means that
they have an on board CPU and expose emulated nand command set

These cards don't even store the  oob area on the flash,
but generate it on the fly from something else.

Thus they demand to have proper values written in the oob area,
and therefore only useful with SmartMedia FTL.

Signed-off-by: Maxim Levitsky <maximlevitsky@gmail.com>
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>

4 files changed, 1292 insertions, 0 deletions

diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig
index 7a67218e86fc..6701a00b7a9a 100644
--- a/drivers/mtd/nand/Kconfig
+++ b/drivers/mtd/nand/Kconfig
@@ -102,6 +102,17 @@ config MTD_NAND_OMAP_PREFETCH_DMA
 config MTD_NAND_IDS
         tristate
 
+config MTD_NAND_RICOH
+        tristate "Ricoh xD card reader"
+        default n
+        select MTD_SM_COMMON
+        help
+          Enable support for Ricoh R5C852 xD card reader
+          You also need to enable ether
+          NAND SSFDC (SmartMedia) read only translation layer' or new
+          expermental, readwrite
+          'SmartMedia/xD new translation layer'
+
 config MTD_NAND_AU1550
         tristate "Au1550/1200 NAND support"
         depends on SOC_AU1200 || SOC_AU1550
diff --git a/drivers/mtd/nand/Makefile b/drivers/mtd/nand/Makefile
index f39d0b6ed42c..5fbd1f83afb6 100644
--- a/drivers/mtd/nand/Makefile
+++ b/drivers/mtd/nand/Makefile
@@ -43,5 +43,6 @@ obj-$(CONFIG_MTD_NAND_NUC900)		+= nuc900_nand.o
 obj-$(CONFIG_MTD_NAND_NOMADIK)          += nomadik_nand.o
 obj-$(CONFIG_MTD_NAND_BCM_UMI)          += bcm_umi_nand.o nand_bcm_umi.o
 obj-$(CONFIG_MTD_NAND_MPC5121_NFC)      += mpc5121_nfc.o
+obj-$(CONFIG_MTD_NAND_RICOH)            += r852.o
 
 nand-objs := nand_base.o nand_bbt.o
diff --git a/drivers/mtd/nand/r852.c b/drivers/mtd/nand/r852.c
new file mode 100644
index 000000000000..9307a88e5229
--- /dev/null
+++ b/drivers/mtd/nand/r852.c
@@ -0,0 +1,1117 @@
+/*
+ * Copyright © 2009 - Maxim Levitsky
+ * driver for Ricoh xD readers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/jiffies.h>
+#include <linux/workqueue.h>
+#include <linux/interrupt.h>
+#include <linux/pci_ids.h>
+#include <asm/byteorder.h>
+#include <linux/sched.h>
+#include "sm_common.h"
+#include "r852.h"
+
+
+static int enable_dma = 1;
+module_param(enable_dma, bool, S_IRUGO);
+MODULE_PARM_DESC(enable_dma, "Enable usage of the DMA (default)");
+
+static int debug;
+module_param(debug, int, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "Debug level (0-2)");
+
+/* read register */
+static inline uint8_t r852_read_reg(struct r852_device *dev, int address)
+{
+        uint8_t reg = readb(dev->mmio + address);
+        return reg;
+}
+
+/* write register */
+static inline void r852_write_reg(struct r852_device *dev,
+                                                int address, uint8_t value)
+{
+        writeb(value, dev->mmio + address);
+        mmiowb();
+}
+
+
+/* read dword sized register */
+static inline uint32_t r852_read_reg_dword(struct r852_device *dev, int address)
+{
+        uint32_t reg = le32_to_cpu(readl(dev->mmio + address));
+        return reg;
+}
+
+/* write dword sized register */
+static inline void r852_write_reg_dword(struct r852_device *dev,
+                                                        int address, uint32_t value)
+{
+        writel(cpu_to_le32(value), dev->mmio + address);
+        mmiowb();
+}
+
+/* returns pointer to our private structure */
+static inline struct r852_device *r852_get_dev(struct mtd_info *mtd)
+{
+        struct nand_chip *chip = (struct nand_chip *)mtd->priv;
+        return (struct r852_device *)chip->priv;
+}
+
+
+/* check if controller supports dma */
+static void r852_dma_test(struct r852_device *dev)
+{
+        dev->dma_usable = (r852_read_reg(dev, R852_DMA_CAP) &
+                (R852_DMA1 | R852_DMA2)) == (R852_DMA1 | R852_DMA2);
+
+        if (!dev->dma_usable)
+                message("Non dma capable device detected, dma disabled");
+
+        if (!enable_dma) {
+                message("disabling dma on user request");
+                dev->dma_usable = 0;
+        }
+}
+
+/*
+ * Enable dma. Enables ether first or second stage of the DMA,
+ * Expects dev->dma_dir and dev->dma_state be set
+ */
+static void r852_dma_enable(struct r852_device *dev)
+{
+        uint8_t dma_reg, dma_irq_reg;
+
+        /* Set up dma settings */
+        dma_reg = r852_read_reg_dword(dev, R852_DMA_SETTINGS);
+        dma_reg &= ~(R852_DMA_READ | R852_DMA_INTERNAL | R852_DMA_MEMORY);
+
+        if (dev->dma_dir)
+                dma_reg |= R852_DMA_READ;
+
+        if (dev->dma_state == DMA_INTERNAL)
+                dma_reg |= R852_DMA_INTERNAL;
+        else {
+                dma_reg |= R852_DMA_MEMORY;
+                r852_write_reg_dword(dev, R852_DMA_ADDR,
+                        cpu_to_le32(dev->phys_dma_addr));
+        }
+
+        r852_write_reg_dword(dev, R852_DMA_SETTINGS, dma_reg);
+
+        /* Set dma irq */
+        dma_irq_reg = r852_read_reg_dword(dev, R852_DMA_IRQ_ENABLE);
+        r852_write_reg_dword(dev, R852_DMA_IRQ_ENABLE,
+                dma_irq_reg |
+                R852_DMA_IRQ_INTERNAL |
+                R852_DMA_IRQ_ERROR |
+                R852_DMA_IRQ_MEMORY);
+}
+
+/*
+ * Disable dma, called from the interrupt handler, which specifies
+ * success of the operation via 'error' argument
+ */
+static void r852_dma_done(struct r852_device *dev, int error)
+{
+        WARN_ON(dev->dma_stage == 0);
+
+        r852_write_reg_dword(dev, R852_DMA_IRQ_STA,
+                        r852_read_reg_dword(dev, R852_DMA_IRQ_STA));
+
+        r852_write_reg_dword(dev, R852_DMA_SETTINGS, 0);
+        r852_write_reg_dword(dev, R852_DMA_IRQ_ENABLE, 0);
+
+        dev->dma_error = error;
+        dev->dma_stage = 0;
+
+        if (dev->phys_dma_addr && dev->phys_dma_addr != dev->phys_bounce_buffer)
+                pci_unmap_single(dev->pci_dev, dev->phys_dma_addr, R852_DMA_LEN,
+                        dev->dma_dir ? PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
+        complete(&dev->dma_done);
+}
+
+/*
+ * Wait, till dma is done, which includes both phases of it
+ */
+static int r852_dma_wait(struct r852_device *dev)
+{
+        long timeout = wait_for_completion_timeout(&dev->dma_done,
+                                msecs_to_jiffies(1000));
+        if (!timeout) {
+                dbg("timeout waiting for DMA interrupt");
+                return -ETIMEDOUT;
+        }
+
+        return 0;
+}
+
+/*
+ * Read/Write one page using dma. Only pages can be read (512 bytes)
+*/
+static void r852_do_dma(struct r852_device *dev, uint8_t *buf, int do_read)
+{
+        int bounce = 0;
+        unsigned long flags;
+        int error;
+
+        dev->dma_error = 0;
+
+        /* Set dma direction */
+        dev->dma_dir = do_read;
+        dev->dma_stage = 1;
+
+        dbg_verbose("doing dma %s ", do_read ? "read" : "write");
+
+        /* Set intial dma state: for reading first fill on board buffer,
+          from device, for writes first fill the buffer  from memory*/
+        dev->dma_state = do_read ? DMA_INTERNAL : DMA_MEMORY;
+
+        /* if incoming buffer is not page aligned, we should do bounce */
+        if ((unsigned long)buf & (R852_DMA_LEN-1))
+                bounce = 1;
+
+        if (!bounce) {
+                dev->phys_dma_addr = pci_map_single(dev->pci_dev, (void *)buf,
+                        R852_DMA_LEN,
+                        (do_read ? PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE));
+
+                if (dev->phys_dma_addr == DMA_ERROR_CODE)
+                        bounce = 1;
+        }
+
+        if (bounce) {
+                dbg_verbose("dma: using bounce buffer");
+                dev->phys_dma_addr = dev->phys_bounce_buffer;
+                if (!do_read)
+                        memcpy(dev->bounce_buffer, buf, R852_DMA_LEN);
+        }
+
+        /* Enable DMA */
+        spin_lock_irqsave(&dev->irqlock, flags);
+        r852_dma_enable(dev);
+        spin_unlock_irqrestore(&dev->irqlock, flags);
+
+        /* Wait till complete */
+        error = r852_dma_wait(dev);
+
+        if (error) {
+                r852_dma_done(dev, error);
+                return;
+        }
+
+        if (do_read && bounce)
+                memcpy((void *)buf, dev->bounce_buffer, R852_DMA_LEN);
+}
+
+/*
+ * Program data lines of the nand chip to send data to it
+ */
+void r852_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
+{
+        struct r852_device *dev = r852_get_dev(mtd);
+        uint32_t reg;
+
+        /* Don't allow any access to hardware if we suspect card removal */
+        if (dev->card_unstable)
+                return;
+
+        /* Special case for whole sector read */
+        if (len == R852_DMA_LEN && dev->dma_usable) {
+                r852_do_dma(dev, (uint8_t *)buf, 0);
+                return;
+        }
+
+        /* write DWORD chinks - faster */
+        while (len) {
+                reg = buf[0] | buf[1] << 8 | buf[2] << 16 | buf[3] << 24;
+                r852_write_reg_dword(dev, R852_DATALINE, reg);
+                buf += 4;
+                len -= 4;
+
+        }
+
+        /* write rest */
+        while (len)
+                r852_write_reg(dev, R852_DATALINE, *buf++);
+}
+
+/*
+ * Read data lines of the nand chip to retrieve data
+ */
+void r852_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
+{
+        struct r852_device *dev = r852_get_dev(mtd);
+        uint32_t reg;
+
+        if (dev->card_unstable) {
+                /* since we can't signal error here, at least, return
+                        predictable buffer */
+                memset(buf, 0, len);
+                return;
+        }
+
+        /* special case for whole sector read */
+        if (len == R852_DMA_LEN && dev->dma_usable) {
+                r852_do_dma(dev, buf, 1);
+                return;
+        }
+
+        /* read in dword sized chunks */
+        while (len >= 4) {
+
+                reg = r852_read_reg_dword(dev, R852_DATALINE);
+                *buf++ = reg & 0xFF;
+                *buf++ = (reg >> 8) & 0xFF;
+                *buf++ = (reg >> 16) & 0xFF;
+                *buf++ = (reg >> 24) & 0xFF;
+                len -= 4;
+        }
+
+        /* read the reset by bytes */
+        while (len--)
+                *buf++ = r852_read_reg(dev, R852_DATALINE);
+}
+
+/*
+ * Read one byte from nand chip
+ */
+static uint8_t r852_read_byte(struct mtd_info *mtd)
+{
+        struct r852_device *dev = r852_get_dev(mtd);
+
+        /* Same problem as in r852_read_buf.... */
+        if (dev->card_unstable)
+                return 0;
+
+        return r852_read_reg(dev, R852_DATALINE);
+}
+
+
+/*
+ * Readback the buffer to verify it
+ */
+int r852_verify_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
+{
+        struct r852_device *dev = r852_get_dev(mtd);
+
+        /* We can't be sure about anything here... */
+        if (dev->card_unstable)
+                return -1;
+
+        /* This will never happen, unless you wired up a nand chip
+                with > 512 bytes page size to the reader */
+        if (len > SM_SECTOR_SIZE)
+                return 0;
+
+        r852_read_buf(mtd, dev->tmp_buffer, len);
+        return memcmp(buf, dev->tmp_buffer, len);
+}
+
+/*
+ * Control several chip lines & send commands
+ */
+void r852_cmdctl(struct mtd_info *mtd, int dat, unsigned int ctrl)
+{
+        struct r852_device *dev = r852_get_dev(mtd);
+
+        if (dev->card_unstable)
+                return;
+
+        if (ctrl & NAND_CTRL_CHANGE) {
+
+                dev->ctlreg &= ~(R852_CTL_DATA | R852_CTL_COMMAND |
+                                 R852_CTL_ON | R852_CTL_CARDENABLE);
+
+                if (ctrl & NAND_ALE)
+                        dev->ctlreg |= R852_CTL_DATA;
+
+                if (ctrl & NAND_CLE)
+                        dev->ctlreg |= R852_CTL_COMMAND;
+
+                if (ctrl & NAND_NCE)
+                        dev->ctlreg |= (R852_CTL_CARDENABLE | R852_CTL_ON);
+                else
+                        dev->ctlreg &= ~R852_CTL_WRITE;
+
+                /* when write is stareted, enable write access */
+                if (dat == NAND_CMD_ERASE1)
+                        dev->ctlreg |= R852_CTL_WRITE;
+
+                r852_write_reg(dev, R852_CTL, dev->ctlreg);
+        }
+
+         /* HACK: NAND_CMD_SEQIN is called without NAND_CTRL_CHANGE, but we need
+                to set write mode */
+        if (dat == NAND_CMD_SEQIN && (dev->ctlreg & R852_CTL_COMMAND)) {
+                dev->ctlreg |= R852_CTL_WRITE;
+                r852_write_reg(dev, R852_CTL, dev->ctlreg);
+        }
+
+        if (dat != NAND_CMD_NONE)
+                r852_write_reg(dev, R852_DATALINE, dat);
+}
+
+/*
+ * Wait till card is ready.
+ * based on nand_wait, but returns errors on DMA error
+ */
+int r852_wait(struct mtd_info *mtd, struct nand_chip *chip)
+{
+        struct r852_device *dev = (struct r852_device *)chip->priv;
+
+        unsigned long timeout;
+        int status;
+
+        timeout = jiffies + (chip->state == FL_ERASING ?
+                msecs_to_jiffies(400) : msecs_to_jiffies(20));
+
+        while (time_before(jiffies, timeout))
+                if (chip->dev_ready(mtd))
+                        break;
+
+        chip->cmdfunc(mtd, NAND_CMD_STATUS, -1, -1);
+        status = (int)chip->read_byte(mtd);
+
+        /* Unfortunelly, no way to send detailed error status... */
+        if (dev->dma_error) {
+                status |= NAND_STATUS_FAIL;
+                dev->dma_error = 0;
+        }
+        return status;
+}
+
+/*
+ * Check if card is ready
+ */
+
+int r852_ready(struct mtd_info *mtd)
+{
+        struct r852_device *dev = r852_get_dev(mtd);
+        return !(r852_read_reg(dev, R852_CARD_STA) & R852_CARD_STA_BUSY);
+}
+
+
+/*
+ * Set ECC engine mode
+*/
+
+void r852_ecc_hwctl(struct mtd_info *mtd, int mode)
+{
+        struct r852_device *dev = r852_get_dev(mtd);
+
+        if (dev->card_unstable)
+                return;
+
+        switch (mode) {
+        case NAND_ECC_READ:
+        case NAND_ECC_WRITE:
+                /* enable ecc generation/check*/
+                dev->ctlreg |= R852_CTL_ECC_ENABLE;
+
+                /* flush ecc buffer */
+                r852_write_reg(dev, R852_CTL,
+                        dev->ctlreg | R852_CTL_ECC_ACCESS);
+
+                r852_read_reg_dword(dev, R852_DATALINE);
+                r852_write_reg(dev, R852_CTL, dev->ctlreg);
+                return;
+
+        case NAND_ECC_READSYN:
+                /* disable ecc generation */
+                dev->ctlreg &= ~R852_CTL_ECC_ENABLE;
+                r852_write_reg(dev, R852_CTL, dev->ctlreg);
+        }
+}
+
+/*
+ * Calculate ECC, only used for writes
+ */
+
+int r852_ecc_calculate(struct mtd_info *mtd, const uint8_t *dat,
+                                                        uint8_t *ecc_code)
+{
+        struct r852_device *dev = r852_get_dev(mtd);
+        struct sm_oob *oob = (struct sm_oob *)ecc_code;
+        uint32_t ecc1, ecc2;
+
+        if (dev->card_unstable)
+                return 0;
+
+        dev->ctlreg &= ~R852_CTL_ECC_ENABLE;
+        r852_write_reg(dev, R852_CTL, dev->ctlreg | R852_CTL_ECC_ACCESS);
+
+        ecc1 = r852_read_reg_dword(dev, R852_DATALINE);
+        ecc2 = r852_read_reg_dword(dev, R852_DATALINE);
+
+        oob->ecc1[0] = (ecc1) & 0xFF;
+        oob->ecc1[1] = (ecc1 >> 8) & 0xFF;
+        oob->ecc1[2] = (ecc1 >> 16) & 0xFF;
+
+        oob->ecc2[0] = (ecc2) & 0xFF;
+        oob->ecc2[1] = (ecc2 >> 8) & 0xFF;
+        oob->ecc2[2] = (ecc2 >> 16) & 0xFF;
+
+        r852_write_reg(dev, R852_CTL, dev->ctlreg);
+        return 0;
+}
+
+/*
+ * Correct the data using ECC, hw did almost everything for us
+ */
+
+int r852_ecc_correct(struct mtd_info *mtd, uint8_t *dat,
+                                uint8_t *read_ecc, uint8_t *calc_ecc)
+{
+        uint16_t ecc_reg;
+        uint8_t ecc_status, err_byte;
+        int i, error = 0;
+
+        struct r852_device *dev = r852_get_dev(mtd);
+
+        if (dev->card_unstable)
+                return 0;
+
+        r852_write_reg(dev, R852_CTL, dev->ctlreg | R852_CTL_ECC_ACCESS);
+        ecc_reg = r852_read_reg_dword(dev, R852_DATALINE);
+        r852_write_reg(dev, R852_CTL, dev->ctlreg);
+
+        for (i = 0 ; i <= 1 ; i++) {
+
+                ecc_status = (ecc_reg >> 8) & 0xFF;
+
+                /* ecc uncorrectable error */
+                if (ecc_status & R852_ECC_FAIL) {
+                        dbg("ecc: unrecoverable error, in half %d", i);
+                        error = -1;
+                        goto exit;
+                }
+
+                /* correctable error */
+                if (ecc_status & R852_ECC_CORRECTABLE) {
+
+                        err_byte = ecc_reg & 0xFF;
+                        dbg("ecc: recoverable error, "
+                                "in half %d, byte %d, bit %d", i,
+                                err_byte, ecc_status & R852_ECC_ERR_BIT_MSK);
+
+                        dat[err_byte] ^=
+                                1 << (ecc_status & R852_ECC_ERR_BIT_MSK);
+                        error++;
+                }
+
+                dat += 256;
+                ecc_reg >>= 16;
+        }
+exit:
+        return error;
+}
+
+/*
+ * This is copy of nand_read_oob_std
+ * nand_read_oob_syndrome assumes we can send column address - we can't
+ */
+static int r852_read_oob(struct mtd_info *mtd, struct nand_chip *chip,
+                             int page, int sndcmd)
+{
+        if (sndcmd) {
+                chip->cmdfunc(mtd, NAND_CMD_READOOB, 0, page);
+                sndcmd = 0;
+        }
+        chip->read_buf(mtd, chip->oob_poi, mtd->oobsize);
+        return sndcmd;
+}
+
+/*
+ * Start the nand engine
+ */
+
+void r852_engine_enable(struct r852_device *dev)
+{
+        if (r852_read_reg_dword(dev, R852_HW) & R852_HW_UNKNOWN) {
+                r852_write_reg(dev, R852_CTL, R852_CTL_RESET | R852_CTL_ON);
+                r852_write_reg_dword(dev, R852_HW, R852_HW_ENABLED);
+        } else {
+                r852_write_reg_dword(dev, R852_HW, R852_HW_ENABLED);
+                r852_write_reg(dev, R852_CTL, R852_CTL_RESET | R852_CTL_ON);
+        }
+        msleep(300);
+        r852_write_reg(dev, R852_CTL, 0);
+}
+
+
+/*
+ * Stop the nand engine
+ */
+
+void r852_engine_disable(struct r852_device *dev)
+{
+        r852_write_reg_dword(dev, R852_HW, 0);
+        r852_write_reg(dev, R852_CTL, R852_CTL_RESET);
+}
+
+/*
+ * Test if card is present
+ */
+
+void r852_card_update_present(struct r852_device *dev)
+{
+        unsigned long flags;
+        uint8_t reg;
+
+        spin_lock_irqsave(&dev->irqlock, flags);
+        reg = r852_read_reg(dev, R852_CARD_STA);
+        dev->card_detected = !!(reg & R852_CARD_STA_PRESENT);
+        spin_unlock_irqrestore(&dev->irqlock, flags);
+}
+
+/*
+ * Update card detection IRQ state according to current card state
+ * which is read in r852_card_update_present
+ */
+void r852_update_card_detect(struct r852_device *dev)
+{
+        int card_detect_reg = r852_read_reg(dev, R852_CARD_IRQ_ENABLE);
+
+        card_detect_reg &= ~(R852_CARD_IRQ_REMOVE | R852_CARD_IRQ_INSERT);
+        card_detect_reg |= R852_CARD_IRQ_GENABLE;
+
+        card_detect_reg |= dev->card_detected ?
+                R852_CARD_IRQ_REMOVE : R852_CARD_IRQ_INSERT;
+
+        r852_write_reg(dev, R852_CARD_IRQ_ENABLE, card_detect_reg);
+}
+
+ssize_t r852_media_type_show(struct device *sys_dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct mtd_info *mtd = container_of(sys_dev, struct mtd_info, dev);
+        struct r852_device *dev = r852_get_dev(mtd);
+        char *data = dev->sm ? "smartmedia" : "xd";
+
+        strcpy(buf, data);
+        return strlen(data);
+}
+
+DEVICE_ATTR(media_type, S_IRUGO, r852_media_type_show, NULL);
+
+
+/* Detect properties of card in slot */
+void r852_update_media_status(struct r852_device *dev)
+{
+        uint8_t reg;
+        unsigned long flags;
+        int readonly;
+
+        spin_lock_irqsave(&dev->irqlock, flags);
+        if (!dev->card_detected) {
+                message("card removed");
+                spin_unlock_irqrestore(&dev->irqlock, flags);
+                return ;
+        }
+
+        readonly  = r852_read_reg(dev, R852_CARD_STA) & R852_CARD_STA_RO;
+        reg = r852_read_reg(dev, R852_DMA_CAP);
+        dev->sm = (reg & (R852_DMA1 | R852_DMA2)) && (reg & R852_SMBIT);
+
+        message("detected %s %s card in slot",
+                dev->sm ? "SmartMedia" : "xD",
+                readonly ? "readonly" : "writeable");
+
+        dev->readonly = readonly;
+        spin_unlock_irqrestore(&dev->irqlock, flags);
+}
+
+/*
+ * Register the nand device
+ * Called when the card is detected
+ */
+int r852_register_nand_device(struct r852_device *dev)
+{
+        dev->mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
+
+        if (!dev->mtd)
+                goto error1;
+
+        WARN_ON(dev->card_registred);
+
+        dev->mtd->owner = THIS_MODULE;
+        dev->mtd->priv = dev->chip;
+        dev->mtd->dev.parent = &dev->pci_dev->dev;
+
+        if (dev->readonly)
+                dev->chip->options |= NAND_ROM;
+
+        r852_engine_enable(dev);
+
+        if (sm_register_device(dev->mtd))
+                goto error2;
+
+        device_create_file(&dev->mtd->dev, &dev_attr_media_type);
+        dev->card_registred = 1;
+        return 0;
+error2:
+        kfree(dev->mtd);
+error1:
+        /* Force card redetect */
+        dev->card_detected = 0;
+        return -1;
+}
+
+/*
+ * Unregister the card
+ */
+
+void r852_unregister_nand_device(struct r852_device *dev)
+{
+        if (!dev->card_registred)
+                return;
+
+        device_remove_file(&dev->mtd->dev, &dev_attr_media_type);
+        nand_release(dev->mtd);
+        r852_engine_disable(dev);
+        dev->card_registred = 0;
+        kfree(dev->mtd);
+        dev->mtd = NULL;
+}
+
+/* Card state updater */
+void r852_card_detect_work(struct work_struct *work)
+{
+        struct r852_device *dev =
+                container_of(work, struct r852_device, card_detect_work.work);
+
+        r852_update_card_detect(dev);
+        dev->card_unstable = 0;
+
+        /* false alarm */
+        if (dev->card_detected == dev->card_registred)
+                goto exit;
+
+        /* Read media properties */
+        r852_update_media_status(dev);
+
+        /* Register the card */
+        if (dev->card_detected)
+                r852_register_nand_device(dev);
+        else
+                r852_unregister_nand_device(dev);
+exit:
+        /* Update detection logic */
+        r852_update_card_detect(dev);
+}
+
+/* Ack + disable IRQ generation */
+static void r852_disable_irqs(struct r852_device *dev)
+{
+        uint8_t reg;
+        reg = r852_read_reg(dev, R852_CARD_IRQ_ENABLE);
+        r852_write_reg(dev, R852_CARD_IRQ_ENABLE, reg & ~R852_CARD_IRQ_MASK);
+
+        reg = r852_read_reg_dword(dev, R852_DMA_IRQ_ENABLE);
+        r852_write_reg_dword(dev, R852_DMA_IRQ_ENABLE,
+                                        reg & ~R852_DMA_IRQ_MASK);
+
+        r852_write_reg(dev, R852_CARD_IRQ_STA, R852_CARD_IRQ_MASK);
+        r852_write_reg_dword(dev, R852_DMA_IRQ_STA, R852_DMA_IRQ_MASK);
+}
+
+/* Interrupt handler */
+static irqreturn_t r852_irq(int irq, void *data)
+{
+        struct r852_device *dev = (struct r852_device *)data;
+
+        uint8_t card_status, dma_status;
+        unsigned long flags;
+        irqreturn_t ret = IRQ_NONE;
+
+        spin_lock_irqsave(&dev->irqlock, flags);
+
+        /* We can recieve shared interrupt while pci is suspended
+                in that case reads will return 0xFFFFFFFF.... */
+        if (dev->insuspend)
+                goto out;
+
+        /* handle card detection interrupts first */
+        card_status = r852_read_reg(dev, R852_CARD_IRQ_STA);
+        r852_write_reg(dev, R852_CARD_IRQ_STA, card_status);
+
+        if (card_status & (R852_CARD_IRQ_INSERT|R852_CARD_IRQ_REMOVE)) {
+
+                ret = IRQ_HANDLED;
+                dev->card_detected = !!(card_status & R852_CARD_IRQ_INSERT);
+
+                /* we shouldn't recieve any interrupts if we wait for card
+                        to settle */
+                WARN_ON(dev->card_unstable);
+
+                /* disable irqs while card is unstable */
+                /* this will timeout DMA if active, but better that garbage */
+                r852_disable_irqs(dev);
+
+                if (dev->card_unstable)
+                        goto out;
+
+                /* let, card state to settle a bit, and then do the work */
+                dev->card_unstable = 1;
+                queue_delayed_work(dev->card_workqueue,
+                        &dev->card_detect_work, msecs_to_jiffies(100));
+                goto out;
+        }
+
+
+        /* Handle dma interrupts */
+        dma_status = r852_read_reg_dword(dev, R852_DMA_IRQ_STA);
+        r852_write_reg_dword(dev, R852_DMA_IRQ_STA, dma_status);
+
+        if (dma_status & R852_DMA_IRQ_MASK) {
+
+                ret = IRQ_HANDLED;
+
+                if (dma_status & R852_DMA_IRQ_ERROR) {
+                        dbg("recieved dma error IRQ");
+                        r852_dma_done(dev, -EIO);
+                        goto out;
+                }
+
+                /* recieved DMA interrupt out of nowhere? */
+                WARN_ON_ONCE(dev->dma_stage == 0);
+
+                if (dev->dma_stage == 0)
+                        goto out;
+
+                /* done device access */
+                if (dev->dma_state == DMA_INTERNAL &&
+                                (dma_status & R852_DMA_IRQ_INTERNAL)) {
+
+                        dev->dma_state = DMA_MEMORY;
+                        dev->dma_stage++;
+                }
+
+                /* done memory DMA */
+                if (dev->dma_state == DMA_MEMORY &&
+                                (dma_status & R852_DMA_IRQ_MEMORY)) {
+                        dev->dma_state = DMA_INTERNAL;
+                        dev->dma_stage++;
+                }
+
+                /* Enable 2nd half of dma dance */
+                if (dev->dma_stage == 2)
+                        r852_dma_enable(dev);
+
+                /* Operation done */
+                if (dev->dma_stage == 3)
+                        r852_dma_done(dev, 0);
+                goto out;
+        }
+
+        /* Handle unknown interrupts */
+        if (dma_status)
+                dbg("bad dma IRQ status = %x", dma_status);
+
+        if (card_status & ~R852_CARD_STA_CD)
+                dbg("strange card status = %x", card_status);
+
+out:
+        spin_unlock_irqrestore(&dev->irqlock, flags);
+        return ret;
+}
+
+int  r852_probe(struct pci_dev *pci_dev, const struct pci_device_id *id)
+{
+        int error;
+        struct nand_chip *chip;
+        struct r852_device *dev;
+
+        /* pci initialization */
+        error = pci_enable_device(pci_dev);
+
+        if (error)
+                goto error1;
+
+        pci_set_master(pci_dev);
+
+        error = pci_set_dma_mask(pci_dev, DMA_32BIT_MASK);
+        if (error)
+                goto error2;
+
+        error = pci_request_regions(pci_dev, DRV_NAME);
+
+        if (error)
+                goto error3;
+
+        error = -ENOMEM;
+
+        /* init nand chip, but register it only on card insert */
+        chip = kzalloc(sizeof(struct nand_chip), GFP_KERNEL);
+
+        if (!chip)
+                goto error4;
+
+        /* commands */
+        chip->cmd_ctrl = r852_cmdctl;
+        chip->waitfunc = r852_wait;
+        chip->dev_ready = r852_ready;
+
+        /* I/O */
+        chip->read_byte = r852_read_byte;
+        chip->read_buf = r852_read_buf;
+        chip->write_buf = r852_write_buf;
+        chip->verify_buf = r852_verify_buf;
+
+        /* ecc */
+        chip->ecc.mode = NAND_ECC_HW_SYNDROME;
+        chip->ecc.size = R852_DMA_LEN;
+        chip->ecc.bytes = SM_OOB_SIZE;
+        chip->ecc.hwctl = r852_ecc_hwctl;
+        chip->ecc.calculate = r852_ecc_calculate;
+        chip->ecc.correct = r852_ecc_correct;
+
+        /* TODO: hack */
+        chip->ecc.read_oob = r852_read_oob;
+
+        /* init our device structure */
+        dev = kzalloc(sizeof(struct r852_device), GFP_KERNEL);
+
+        if (!dev)
+                goto error5;
+
+        chip->priv = dev;
+        dev->chip = chip;
+        dev->pci_dev = pci_dev;
+        pci_set_drvdata(pci_dev, dev);
+
+        dev->bounce_buffer = pci_alloc_consistent(pci_dev, R852_DMA_LEN,
+                &dev->phys_bounce_buffer);
+
+        if (!dev->bounce_buffer)
+                goto error6;
+
+
+        error = -ENODEV;
+        dev->mmio = pci_ioremap_bar(pci_dev, 0);
+
+        if (!dev->mmio)
+                goto error7;
+
+        error = -ENOMEM;
+        dev->tmp_buffer = kzalloc(SM_SECTOR_SIZE, GFP_KERNEL);
+
+        if (!dev->tmp_buffer)
+                goto error8;
+
+        init_completion(&dev->dma_done);
+
+        dev->card_workqueue = create_freezeable_workqueue(DRV_NAME);
+
+        if (!dev->card_workqueue)
+                goto error9;
+
+        INIT_DELAYED_WORK(&dev->card_detect_work, r852_card_detect_work);
+
+        /* shutdown everything - precation */
+        r852_engine_disable(dev);
+        r852_disable_irqs(dev);
+
+        r852_dma_test(dev);
+
+        /*register irq handler*/
+        error = -ENODEV;
+        if (request_irq(pci_dev->irq, &r852_irq, IRQF_SHARED,
+                          DRV_NAME, dev))
+                goto error10;
+
+        dev->irq = pci_dev->irq;
+        spin_lock_init(&dev->irqlock);
+
+        /* kick initial present test */
+        dev->card_detected = 0;
+        r852_card_update_present(dev);
+        queue_delayed_work(dev->card_workqueue,
+                &dev->card_detect_work, 0);
+
+
+        printk(KERN_NOTICE DRV_NAME ": driver loaded succesfully\n");
+        return 0;
+
+error10:
+        destroy_workqueue(dev->card_workqueue);
+error9:
+        kfree(dev->tmp_buffer);
+error8:
+        pci_iounmap(pci_dev, dev->mmio);
+error7:
+        pci_free_consistent(pci_dev, R852_DMA_LEN,
+                dev->bounce_buffer, dev->phys_bounce_buffer);
+error6:
+        kfree(dev);
+error5:
+        kfree(chip);
+error4:
+        pci_release_regions(pci_dev);
+error3:
+error2:
+        pci_disable_device(pci_dev);
+error1:
+        return error;
+}
+
+void r852_remove(struct pci_dev *pci_dev)
+{
+        struct r852_device *dev = pci_get_drvdata(pci_dev);
+
+        /* Stop detect workqueue -
+                we are going to unregister the device anyway*/
+        cancel_delayed_work_sync(&dev->card_detect_work);
+        destroy_workqueue(dev->card_workqueue);
+
+        /* Unregister the device, this might make more IO */
+        r852_unregister_nand_device(dev);
+
+        /* Stop interrupts */
+        r852_disable_irqs(dev);
+        synchronize_irq(dev->irq);
+        free_irq(dev->irq, dev);
+
+        /* Cleanup */
+        kfree(dev->tmp_buffer);
+        pci_iounmap(pci_dev, dev->mmio);
+        pci_free_consistent(pci_dev, R852_DMA_LEN,
+                dev->bounce_buffer, dev->phys_bounce_buffer);
+
+        kfree(dev->chip);
+        kfree(dev);
+
+        /* Shutdown the PCI device */
+        pci_release_regions(pci_dev);
+        pci_disable_device(pci_dev);
+}
+
+void r852_shutdown(struct pci_dev *pci_dev)
+{
+        struct r852_device *dev = pci_get_drvdata(pci_dev);
+
+        cancel_delayed_work_sync(&dev->card_detect_work);
+        r852_disable_irqs(dev);
+        synchronize_irq(dev->irq);
+        pci_disable_device(pci_dev);
+}
+
+int r852_suspend(struct device *device)
+{
+        struct r852_device *dev = pci_get_drvdata(to_pci_dev(device));
+        unsigned long flags;
+
+        if (dev->ctlreg & R852_CTL_CARDENABLE)
+                return -EBUSY;
+
+        /* First make sure the detect work is gone */
+        cancel_delayed_work_sync(&dev->card_detect_work);
+
+        /* Turn off the interrupts and stop the device */
+        r852_disable_irqs(dev);
+        r852_engine_disable(dev);
+
+        spin_lock_irqsave(&dev->irqlock, flags);
+        dev->insuspend = 1;
+        spin_unlock_irqrestore(&dev->irqlock, flags);
+
+        /* At that point, even if interrupt handler is running, it will quit */
+        /* So wait for this to happen explictly */
+        synchronize_irq(dev->irq);
+
+        /* If card was pulled off just during the suspend, which is very
+                unlikely, we will remove it on resume, it too late now
+                anyway... */
+        dev->card_unstable = 0;
+
+        pci_save_state(to_pci_dev(device));
+        return pci_prepare_to_sleep(to_pci_dev(device));
+}
+
+int r852_resume(struct device *device)
+{
+        struct r852_device *dev = pci_get_drvdata(to_pci_dev(device));
+        unsigned long flags;
+
+        /* Turn on the hardware */
+        pci_back_from_sleep(to_pci_dev(device));
+        pci_restore_state(to_pci_dev(device));
+
+        r852_disable_irqs(dev);
+        r852_card_update_present(dev);
+        r852_engine_disable(dev);
+
+
+        /* Now its safe for IRQ to run */
+        spin_lock_irqsave(&dev->irqlock, flags);
+        dev->insuspend = 0;
+        spin_unlock_irqrestore(&dev->irqlock, flags);
+
+
+        /* If card status changed, just do the work */
+        if (dev->card_detected != dev->card_registred) {
+                dbg("card was %s during low power state",
+                        dev->card_detected ? "added" : "removed");
+
+                queue_delayed_work(dev->card_workqueue,
+                &dev->card_detect_work, 1000);
+                return 0;
+        }
+
+        /* Otherwise, initialize the card */
+        if (dev->card_registred) {
+                r852_engine_enable(dev);
+                dev->chip->select_chip(dev->mtd, 0);
+                dev->chip->cmdfunc(dev->mtd, NAND_CMD_RESET, -1, -1);
+                dev->chip->select_chip(dev->mtd, -1);
+        }
+
+        /* Program card detection IRQ */
+        r852_update_card_detect(dev);
+        return 0;
+}
+
+static const struct pci_device_id r852_pci_id_tbl[] = {
+
+        { PCI_VDEVICE(RICOH, PCI_DEVICE_ID_RICOH_R5C852), },
+        { },
+};
+
+MODULE_DEVICE_TABLE(pci, r852_pci_id_tbl);
+
+SIMPLE_DEV_PM_OPS(r852_pm_ops, r852_suspend, r852_resume);
+
+
+static struct pci_driver r852_pci_driver = {
+        .name           = DRV_NAME,
+        .id_table       = r852_pci_id_tbl,
+        .probe          = r852_probe,
+        .remove         = r852_remove,
+        .shutdown       = r852_shutdown,
+        .driver.pm      = &r852_pm_ops,
+};
+
+static __init int r852_module_init(void)
+{
+        return pci_register_driver(&r852_pci_driver);
+}
+
+static void __exit r852_module_exit(void)
+{
+        pci_unregister_driver(&r852_pci_driver);
+}
+
+module_init(r852_module_init);
+module_exit(r852_module_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Maxim Levitsky <maximlevitsky@gmail.com>");
+MODULE_DESCRIPTION("Ricoh 85xx xD/smartmedia card reader driver");
diff --git a/drivers/mtd/nand/r852.h b/drivers/mtd/nand/r852.h
new file mode 100644
index 000000000000..8096cc280c73
--- /dev/null
+++ b/drivers/mtd/nand/r852.h
@@ -0,0 +1,163 @@
+/*
+ * Copyright © 2009 - Maxim Levitsky
+ * driver for Ricoh xD readers
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/pci.h>
+#include <linux/completion.h>
+#include <linux/workqueue.h>
+#include <linux/mtd/nand.h>
+#include <linux/spinlock.h>
+
+
+/* nand interface + ecc
+   byte write/read does one cycle on nand data lines.
+   dword write/read does 4 cycles
+   if R852_CTL_ECC_ACCESS is set in R852_CTL, then dword read reads
+   results of ecc correction, if DMA read was done before.
+   If write was done two dword reads read generated ecc checksums
+*/
+#define R852_DATALINE           0x00
+
+/* control register */
+#define R852_CTL                0x04
+#define R852_CTL_COMMAND        0x01    /* send command (#CLE)*/
+#define R852_CTL_DATA           0x02    /* read/write data (#ALE)*/
+#define R852_CTL_ON             0x04    /* only seem to controls the hd led, */
+                                        /* but has to be set on start...*/
+#define R852_CTL_RESET          0x08    /* unknown, set only on start once*/
+#define R852_CTL_CARDENABLE     0x10    /* probably (#CE) - always set*/
+#define R852_CTL_ECC_ENABLE     0x20    /* enable ecc engine */
+#define R852_CTL_ECC_ACCESS     0x40    /* read/write ecc via reg #0*/
+#define R852_CTL_WRITE          0x80    /* set when performing writes (#WP) */
+
+/* card detection status */
+#define R852_CARD_STA           0x05
+
+#define R852_CARD_STA_CD        0x01    /* state of #CD line, same as 0x04 */
+#define R852_CARD_STA_RO        0x02    /* card is readonly */
+#define R852_CARD_STA_PRESENT   0x04    /* card is present (#CD) */
+#define R852_CARD_STA_ABSENT    0x08    /* card is absent */
+#define R852_CARD_STA_BUSY      0x80    /* card is busy - (#R/B) */
+
+/* card detection irq status & enable*/
+#define R852_CARD_IRQ_STA       0x06    /* IRQ status */
+#define R852_CARD_IRQ_ENABLE    0x07    /* IRQ enable */
+
+#define R852_CARD_IRQ_CD        0x01    /* fire when #CD lights, same as 0x04*/
+#define R852_CARD_IRQ_REMOVE    0x04    /* detect card removal */
+#define R852_CARD_IRQ_INSERT    0x08    /* detect card insert */
+#define R852_CARD_IRQ_UNK1      0x10    /* unknown */
+#define R852_CARD_IRQ_GENABLE   0x80    /* general enable */
+#define R852_CARD_IRQ_MASK      0x1D
+
+
+
+/* hardware enable */
+#define R852_HW                 0x08
+#define R852_HW_ENABLED         0x01    /* hw enabled */
+#define R852_HW_UNKNOWN         0x80
+
+
+/* dma capabilities */
+#define R852_DMA_CAP            0x09
+#define R852_SMBIT              0x20    /* if set with bit #6 or bit #7, then */
+                                        /* hw is smartmedia */
+#define R852_DMA1               0x40    /* if set w/bit #7, dma is supported */
+#define R852_DMA2               0x80    /* if set w/bit #6, dma is supported */
+
+
+/* physical DMA address - 32 bit value*/
+#define R852_DMA_ADDR           0x0C
+
+
+/* dma settings */
+#define R852_DMA_SETTINGS       0x10
+#define R852_DMA_MEMORY         0x01    /* (memory <-> internal hw buffer) */
+#define R852_DMA_READ           0x02    /* 0 = write, 1 = read */
+#define R852_DMA_INTERNAL       0x04    /* (internal hw buffer <-> card) */
+
+/* dma IRQ status */
+#define R852_DMA_IRQ_STA                0x14
+
+/* dma IRQ enable */
+#define R852_DMA_IRQ_ENABLE     0x18
+
+#define R852_DMA_IRQ_MEMORY     0x01    /* (memory <-> internal hw buffer) */
+#define R852_DMA_IRQ_ERROR      0x02    /* error did happen */
+#define R852_DMA_IRQ_INTERNAL   0x04    /* (internal hw buffer <-> card) */
+#define R852_DMA_IRQ_MASK       0x07    /* mask of all IRQ bits */
+
+
+/* ECC syndrome format - read from reg #0 will return two copies of these for
+   each half of the page.
+   first byte is error byte location, and second, bit location + flags */
+#define R852_ECC_ERR_BIT_MSK    0x07    /* error bit location */
+#define R852_ECC_CORRECT                0x10    /* no errors - (guessed) */
+#define R852_ECC_CORRECTABLE    0x20    /* correctable error exist */
+#define R852_ECC_FAIL           0x40    /* non correctable error detected */
+
+#define R852_DMA_LEN            512
+
+#define DMA_INTERNAL    0
+#define DMA_MEMORY      1
+
+struct r852_device {
+        void __iomem *mmio;             /* mmio */
+        struct mtd_info *mtd;           /* mtd backpointer */
+        struct nand_chip *chip;         /* nand chip backpointer */
+        struct pci_dev *pci_dev;        /* pci backpointer */
+
+        /* dma area */
+        dma_addr_t phys_dma_addr;       /* bus address of buffer*/
+        struct completion dma_done;     /* data transfer done */
+
+        dma_addr_t phys_bounce_buffer;  /* bus address of bounce buffer */
+        uint8_t *bounce_buffer;         /* virtual address of bounce buffer */
+
+        int dma_dir;                    /* 1 = read, 0 = write */
+        int dma_stage;                  /* 0 - idle, 1 - first step,
+                                           2 - second step */
+
+        int dma_state;                  /* 0 = internal, 1 = memory */
+        int dma_error;                  /* dma errors */
+        int dma_usable;                 /* is it possible to use dma */
+
+        /* card status area */
+        struct delayed_work card_detect_work;
+        struct workqueue_struct *card_workqueue;
+        int card_registred;             /* card registered with mtd */
+        int card_detected;              /* card detected in slot */
+        int card_unstable;              /* whenever the card is inserted,
+                                           is not known yet */
+        int readonly;                   /* card is readonly */
+        int sm;                         /* Is card smartmedia */
+
+        /* interrupt handling */
+        spinlock_t irqlock;             /* IRQ protecting lock */
+        int irq;                        /* irq num */
+        int insuspend;                  /* device is suspended */
+
+        /* misc */
+        void *tmp_buffer;               /* temporary buffer */
+        uint8_t ctlreg;                 /* cached contents of control reg */
+};
+
+#define DRV_NAME "r852"
+
+
+#define dbg(format, ...) \
+        if (debug) \
+                printk(KERN_DEBUG DRV_NAME ": " format "\n", ## __VA_ARGS__)
+
+#define dbg_verbose(format, ...) \
+        if (debug > 1) \
+                printk(KERN_DEBUG DRV_NAME ": " format "\n", ## __VA_ARGS__)
+
+
+#define message(format, ...) \
+        printk(KERN_INFO DRV_NAME ": " format "\n", ## __VA_ARGS__)