]> git.karo-electronics.de Git - karo-tx-linux.git/commitdiff
remove the mg_disk driver
authorChristoph Hellwig <hch@lst.de>
Thu, 6 Apr 2017 11:28:46 +0000 (13:28 +0200)
committerJens Axboe <axboe@fb.com>
Fri, 14 Apr 2017 20:00:49 +0000 (14:00 -0600)
This drivers was added in 2008, but as far as a I can tell we never had a
single platform that actually registered resources for the platform driver.

It's also been unmaintained for a long time and apparently has a ATA mode
that can be driven using the IDE/libata subsystem.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Signed-off-by: Jens Axboe <axboe@fb.com>
Documentation/blockdev/mflash.txt [deleted file]
drivers/block/Kconfig
drivers/block/Makefile
drivers/block/mg_disk.c [deleted file]
include/linux/mg_disk.h [deleted file]

diff --git a/Documentation/blockdev/mflash.txt b/Documentation/blockdev/mflash.txt
deleted file mode 100644 (file)
index f7e0505..0000000
+++ /dev/null
@@ -1,84 +0,0 @@
-This document describes m[g]flash support in linux.
-
-Contents
-  1. Overview
-  2. Reserved area configuration
-  3. Example of mflash platform driver registration
-
-1. Overview
-
-Mflash and gflash are embedded flash drive. The only difference is mflash is
-MCP(Multi Chip Package) device. These two device operate exactly same way.
-So the rest mflash repersents mflash and gflash altogether.
-
-Internally, mflash has nand flash and other hardware logics and supports
-2 different operation (ATA, IO) modes. ATA mode doesn't need any new
-driver and currently works well under standard IDE subsystem. Actually it's
-one chip SSD. IO mode is ATA-like custom mode for the host that doesn't have
-IDE interface.
-
-Following are brief descriptions about IO mode.
-A. IO mode based on ATA protocol and uses some custom command. (read confirm,
-write confirm)
-B. IO mode uses SRAM bus interface.
-C. IO mode supports 4kB boot area, so host can boot from mflash.
-
-2. Reserved area configuration
-If host boot from mflash, usually needs raw area for boot loader image. All of
-the mflash's block device operation will be taken this value as start offset.
-Note that boot loader's size of reserved area and kernel configuration value
-must be same.
-
-3. Example of mflash platform driver registration
-Working mflash is very straight forward. Adding platform device stuff to board
-configuration file is all. Here is some pseudo example.
-
-static struct mg_drv_data mflash_drv_data = {
-       /* If you want to polling driver set to 1 */
-       .use_polling = 0,
-       /* device attribution */
-       .dev_attr = MG_BOOT_DEV
-};
-
-static struct resource mg_mflash_rsc[] = {
-       /* Base address of mflash */
-       [0] = {
-               .start = 0x08000000,
-               .end = 0x08000000 + SZ_64K - 1,
-               .flags = IORESOURCE_MEM
-       },
-       /* mflash interrupt pin */
-       [1] = {
-               .start = IRQ_GPIO(84),
-               .end = IRQ_GPIO(84),
-               .flags = IORESOURCE_IRQ
-       },
-       /* mflash reset pin */
-       [2] = {
-               .start = 43,
-               .end = 43,
-               .name = MG_RST_PIN,
-               .flags = IORESOURCE_IO
-       },
-       /* mflash reset-out pin
-        * If you use mflash as storage device (i.e. other than MG_BOOT_DEV),
-        * should assign this */
-       [3] = {
-               .start = 51,
-               .end = 51,
-               .name = MG_RSTOUT_PIN,
-               .flags = IORESOURCE_IO
-       }
-};
-
-static struct platform_device mflash_dev = {
-       .name = MG_DEV_NAME,
-       .id = -1,
-       .dev = {
-               .platform_data = &mflash_drv_data,
-       },
-       .num_resources = ARRAY_SIZE(mg_mflash_rsc),
-       .resource = mg_mflash_rsc
-};
-
-platform_device_register(&mflash_dev);
index a1c2e816128f7af2dfb7d98ad9265fe4710086cc..ebe8c1a6195e991e6226024a61c9b8fcd77ababa 100644 (file)
@@ -434,23 +434,6 @@ config ATA_OVER_ETH
        This driver provides Support for ATA over Ethernet block
        devices like the Coraid EtherDrive (R) Storage Blade.
 
-config MG_DISK
-       tristate "mGine mflash, gflash support"
-       depends on ARM && GPIOLIB
-       help
-         mGine mFlash(gFlash) block device driver
-
-config MG_DISK_RES
-       int "Size of reserved area before MBR"
-       depends on MG_DISK
-       default 0
-       help
-         Define size of reserved area that usually used for boot. Unit is KB.
-         All of the block device operation will be taken this value as start
-         offset
-         Examples:
-                       1024 => 1 MB
-
 config SUNVDC
        tristate "Sun Virtual Disk Client support"
        depends on SUN_LDOMS
index b12c772bbeb304ab4befe8024196dfc8ba1d2c10..5ceead8b52d7ed03bac009f4d1f51981e5ad21ba 100644 (file)
@@ -19,7 +19,6 @@ obj-$(CONFIG_BLK_CPQ_CISS_DA)  += cciss.o
 obj-$(CONFIG_BLK_DEV_DAC960)   += DAC960.o
 obj-$(CONFIG_XILINX_SYSACE)    += xsysace.o
 obj-$(CONFIG_CDROM_PKTCDVD)    += pktcdvd.o
-obj-$(CONFIG_MG_DISK)          += mg_disk.o
 obj-$(CONFIG_SUNVDC)           += sunvdc.o
 obj-$(CONFIG_BLK_DEV_SKD)      += skd.o
 obj-$(CONFIG_BLK_DEV_OSD)      += osdblk.o
diff --git a/drivers/block/mg_disk.c b/drivers/block/mg_disk.c
deleted file mode 100644 (file)
index e88e7b0..0000000
+++ /dev/null
@@ -1,1110 +0,0 @@
-/*
- *  drivers/block/mg_disk.c
- *
- *  Support for the mGine m[g]flash IO mode.
- *  Based on legacy hd.c
- *
- * (c) 2008 mGine Co.,LTD
- * (c) 2008 unsik Kim <donari75@gmail.com>
- *
- *  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/fs.h>
-#include <linux/blkdev.h>
-#include <linux/hdreg.h>
-#include <linux/ata.h>
-#include <linux/interrupt.h>
-#include <linux/delay.h>
-#include <linux/platform_device.h>
-#include <linux/gpio.h>
-#include <linux/mg_disk.h>
-#include <linux/slab.h>
-
-#define MG_RES_SEC (CONFIG_MG_DISK_RES << 1)
-
-/* name for block device */
-#define MG_DISK_NAME "mgd"
-
-#define MG_DISK_MAJ 0
-#define MG_DISK_MAX_PART 16
-#define MG_SECTOR_SIZE 512
-#define MG_MAX_SECTS 256
-
-/* Register offsets */
-#define MG_BUFF_OFFSET                 0x8000
-#define MG_REG_OFFSET                  0xC000
-#define MG_REG_FEATURE                 (MG_REG_OFFSET + 2)     /* write case */
-#define MG_REG_ERROR                   (MG_REG_OFFSET + 2)     /* read case */
-#define MG_REG_SECT_CNT                        (MG_REG_OFFSET + 4)
-#define MG_REG_SECT_NUM                        (MG_REG_OFFSET + 6)
-#define MG_REG_CYL_LOW                 (MG_REG_OFFSET + 8)
-#define MG_REG_CYL_HIGH                        (MG_REG_OFFSET + 0xA)
-#define MG_REG_DRV_HEAD                        (MG_REG_OFFSET + 0xC)
-#define MG_REG_COMMAND                 (MG_REG_OFFSET + 0xE)   /* write case */
-#define MG_REG_STATUS                  (MG_REG_OFFSET + 0xE)   /* read  case */
-#define MG_REG_DRV_CTRL                        (MG_REG_OFFSET + 0x10)
-#define MG_REG_BURST_CTRL              (MG_REG_OFFSET + 0x12)
-
-/* handy status */
-#define MG_STAT_READY  (ATA_DRDY | ATA_DSC)
-#define MG_READY_OK(s) (((s) & (MG_STAT_READY | (ATA_BUSY | ATA_DF | \
-                                ATA_ERR))) == MG_STAT_READY)
-
-/* error code for others */
-#define MG_ERR_NONE            0
-#define MG_ERR_TIMEOUT         0x100
-#define MG_ERR_INIT_STAT       0x101
-#define MG_ERR_TRANSLATION     0x102
-#define MG_ERR_CTRL_RST                0x103
-#define MG_ERR_INV_STAT                0x104
-#define MG_ERR_RSTOUT          0x105
-
-#define MG_MAX_ERRORS  6       /* Max read/write errors */
-
-/* command */
-#define MG_CMD_RD 0x20
-#define MG_CMD_WR 0x30
-#define MG_CMD_SLEEP 0x99
-#define MG_CMD_WAKEUP 0xC3
-#define MG_CMD_ID 0xEC
-#define MG_CMD_WR_CONF 0x3C
-#define MG_CMD_RD_CONF 0x40
-
-/* operation mode */
-#define MG_OP_CASCADE (1 << 0)
-#define MG_OP_CASCADE_SYNC_RD (1 << 1)
-#define MG_OP_CASCADE_SYNC_WR (1 << 2)
-#define MG_OP_INTERLEAVE (1 << 3)
-
-/* synchronous */
-#define MG_BURST_LAT_4 (3 << 4)
-#define MG_BURST_LAT_5 (4 << 4)
-#define MG_BURST_LAT_6 (5 << 4)
-#define MG_BURST_LAT_7 (6 << 4)
-#define MG_BURST_LAT_8 (7 << 4)
-#define MG_BURST_LEN_4 (1 << 1)
-#define MG_BURST_LEN_8 (2 << 1)
-#define MG_BURST_LEN_16 (3 << 1)
-#define MG_BURST_LEN_32 (4 << 1)
-#define MG_BURST_LEN_CONT (0 << 1)
-
-/* timeout value (unit: ms) */
-#define MG_TMAX_CONF_TO_CMD    1
-#define MG_TMAX_WAIT_RD_DRQ    10
-#define MG_TMAX_WAIT_WR_DRQ    500
-#define MG_TMAX_RST_TO_BUSY    10
-#define MG_TMAX_HDRST_TO_RDY   500
-#define MG_TMAX_SWRST_TO_RDY   500
-#define MG_TMAX_RSTOUT         3000
-
-#define MG_DEV_MASK (MG_BOOT_DEV | MG_STORAGE_DEV | MG_STORAGE_DEV_SKIP_RST)
-
-/* main structure for mflash driver */
-struct mg_host {
-       struct device *dev;
-
-       struct request_queue *breq;
-       struct request *req;
-       spinlock_t lock;
-       struct gendisk *gd;
-
-       struct timer_list timer;
-       void (*mg_do_intr) (struct mg_host *);
-
-       u16 id[ATA_ID_WORDS];
-
-       u16 cyls;
-       u16 heads;
-       u16 sectors;
-       u32 n_sectors;
-       u32 nres_sectors;
-
-       void __iomem *dev_base;
-       unsigned int irq;
-       unsigned int rst;
-       unsigned int rstout;
-
-       u32 major;
-       u32 error;
-};
-
-/*
- * Debugging macro and defines
- */
-#undef DO_MG_DEBUG
-#ifdef DO_MG_DEBUG
-#  define MG_DBG(fmt, args...) \
-       printk(KERN_DEBUG "%s:%d "fmt, __func__, __LINE__, ##args)
-#else /* CONFIG_MG_DEBUG */
-#  define MG_DBG(fmt, args...) do { } while (0)
-#endif /* CONFIG_MG_DEBUG */
-
-static void mg_request(struct request_queue *);
-
-static bool mg_end_request(struct mg_host *host, int err, unsigned int nr_bytes)
-{
-       if (__blk_end_request(host->req, err, nr_bytes))
-               return true;
-
-       host->req = NULL;
-       return false;
-}
-
-static bool mg_end_request_cur(struct mg_host *host, int err)
-{
-       return mg_end_request(host, err, blk_rq_cur_bytes(host->req));
-}
-
-static void mg_dump_status(const char *msg, unsigned int stat,
-               struct mg_host *host)
-{
-       char *name = MG_DISK_NAME;
-
-       if (host->req)
-               name = host->req->rq_disk->disk_name;
-
-       printk(KERN_ERR "%s: %s: status=0x%02x { ", name, msg, stat & 0xff);
-       if (stat & ATA_BUSY)
-               printk("Busy ");
-       if (stat & ATA_DRDY)
-               printk("DriveReady ");
-       if (stat & ATA_DF)
-               printk("WriteFault ");
-       if (stat & ATA_DSC)
-               printk("SeekComplete ");
-       if (stat & ATA_DRQ)
-               printk("DataRequest ");
-       if (stat & ATA_CORR)
-               printk("CorrectedError ");
-       if (stat & ATA_ERR)
-               printk("Error ");
-       printk("}\n");
-       if ((stat & ATA_ERR) == 0) {
-               host->error = 0;
-       } else {
-               host->error = inb((unsigned long)host->dev_base + MG_REG_ERROR);
-               printk(KERN_ERR "%s: %s: error=0x%02x { ", name, msg,
-                               host->error & 0xff);
-               if (host->error & ATA_BBK)
-                       printk("BadSector ");
-               if (host->error & ATA_UNC)
-                       printk("UncorrectableError ");
-               if (host->error & ATA_IDNF)
-                       printk("SectorIdNotFound ");
-               if (host->error & ATA_ABORTED)
-                       printk("DriveStatusError ");
-               if (host->error & ATA_AMNF)
-                       printk("AddrMarkNotFound ");
-               printk("}");
-               if (host->error & (ATA_BBK | ATA_UNC | ATA_IDNF | ATA_AMNF)) {
-                       if (host->req)
-                               printk(", sector=%u",
-                                      (unsigned int)blk_rq_pos(host->req));
-               }
-               printk("\n");
-       }
-}
-
-static unsigned int mg_wait(struct mg_host *host, u32 expect, u32 msec)
-{
-       u8 status;
-       unsigned long expire, cur_jiffies;
-       struct mg_drv_data *prv_data = host->dev->platform_data;
-
-       host->error = MG_ERR_NONE;
-       expire = jiffies + msecs_to_jiffies(msec);
-
-       /* These 2 times dummy status read prevents reading invalid
-        * status. A very little time (3 times of mflash operating clk)
-        * is required for busy bit is set. Use dummy read instead of
-        * busy wait, because mflash's PLL is machine dependent.
-        */
-       if (prv_data->use_polling) {
-               status = inb((unsigned long)host->dev_base + MG_REG_STATUS);
-               status = inb((unsigned long)host->dev_base + MG_REG_STATUS);
-       }
-
-       status = inb((unsigned long)host->dev_base + MG_REG_STATUS);
-
-       do {
-               cur_jiffies = jiffies;
-               if (status & ATA_BUSY) {
-                       if (expect == ATA_BUSY)
-                               break;
-               } else {
-                       /* Check the error condition! */
-                       if (status & ATA_ERR) {
-                               mg_dump_status("mg_wait", status, host);
-                               break;
-                       }
-
-                       if (expect == MG_STAT_READY)
-                               if (MG_READY_OK(status))
-                                       break;
-
-                       if (expect == ATA_DRQ)
-                               if (status & ATA_DRQ)
-                                       break;
-               }
-               if (!msec) {
-                       mg_dump_status("not ready", status, host);
-                       return MG_ERR_INV_STAT;
-               }
-
-               status = inb((unsigned long)host->dev_base + MG_REG_STATUS);
-       } while (time_before(cur_jiffies, expire));
-
-       if (time_after_eq(cur_jiffies, expire) && msec)
-               host->error = MG_ERR_TIMEOUT;
-
-       return host->error;
-}
-
-static unsigned int mg_wait_rstout(u32 rstout, u32 msec)
-{
-       unsigned long expire;
-
-       expire = jiffies + msecs_to_jiffies(msec);
-       while (time_before(jiffies, expire)) {
-               if (gpio_get_value(rstout) == 1)
-                       return MG_ERR_NONE;
-               msleep(10);
-       }
-
-       return MG_ERR_RSTOUT;
-}
-
-static void mg_unexpected_intr(struct mg_host *host)
-{
-       u32 status = inb((unsigned long)host->dev_base + MG_REG_STATUS);
-
-       mg_dump_status("mg_unexpected_intr", status, host);
-}
-
-static irqreturn_t mg_irq(int irq, void *dev_id)
-{
-       struct mg_host *host = dev_id;
-       void (*handler)(struct mg_host *) = host->mg_do_intr;
-
-       spin_lock(&host->lock);
-
-       host->mg_do_intr = NULL;
-       del_timer(&host->timer);
-       if (!handler)
-               handler = mg_unexpected_intr;
-       handler(host);
-
-       spin_unlock(&host->lock);
-
-       return IRQ_HANDLED;
-}
-
-/* local copy of ata_id_string() */
-static void mg_id_string(const u16 *id, unsigned char *s,
-                        unsigned int ofs, unsigned int len)
-{
-       unsigned int c;
-
-       BUG_ON(len & 1);
-
-       while (len > 0) {
-               c = id[ofs] >> 8;
-               *s = c;
-               s++;
-
-               c = id[ofs] & 0xff;
-               *s = c;
-               s++;
-
-               ofs++;
-               len -= 2;
-       }
-}
-
-/* local copy of ata_id_c_string() */
-static void mg_id_c_string(const u16 *id, unsigned char *s,
-                          unsigned int ofs, unsigned int len)
-{
-       unsigned char *p;
-
-       mg_id_string(id, s, ofs, len - 1);
-
-       p = s + strnlen(s, len - 1);
-       while (p > s && p[-1] == ' ')
-               p--;
-       *p = '\0';
-}
-
-static int mg_get_disk_id(struct mg_host *host)
-{
-       u32 i;
-       s32 err;
-       const u16 *id = host->id;
-       struct mg_drv_data *prv_data = host->dev->platform_data;
-       char fwrev[ATA_ID_FW_REV_LEN + 1];
-       char model[ATA_ID_PROD_LEN + 1];
-       char serial[ATA_ID_SERNO_LEN + 1];
-
-       if (!prv_data->use_polling)
-               outb(ATA_NIEN, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-
-       outb(MG_CMD_ID, (unsigned long)host->dev_base + MG_REG_COMMAND);
-       err = mg_wait(host, ATA_DRQ, MG_TMAX_WAIT_RD_DRQ);
-       if (err)
-               return err;
-
-       for (i = 0; i < (MG_SECTOR_SIZE >> 1); i++)
-               host->id[i] = le16_to_cpu(inw((unsigned long)host->dev_base +
-                                       MG_BUFF_OFFSET + i * 2));
-
-       outb(MG_CMD_RD_CONF, (unsigned long)host->dev_base + MG_REG_COMMAND);
-       err = mg_wait(host, MG_STAT_READY, MG_TMAX_CONF_TO_CMD);
-       if (err)
-               return err;
-
-       if ((id[ATA_ID_FIELD_VALID] & 1) == 0)
-               return MG_ERR_TRANSLATION;
-
-       host->n_sectors = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
-       host->cyls = id[ATA_ID_CYLS];
-       host->heads = id[ATA_ID_HEADS];
-       host->sectors = id[ATA_ID_SECTORS];
-
-       if (MG_RES_SEC && host->heads && host->sectors) {
-               /* modify cyls, n_sectors */
-               host->cyls = (host->n_sectors - MG_RES_SEC) /
-                       host->heads / host->sectors;
-               host->nres_sectors = host->n_sectors - host->cyls *
-                       host->heads * host->sectors;
-               host->n_sectors -= host->nres_sectors;
-       }
-
-       mg_id_c_string(id, fwrev, ATA_ID_FW_REV, sizeof(fwrev));
-       mg_id_c_string(id, model, ATA_ID_PROD, sizeof(model));
-       mg_id_c_string(id, serial, ATA_ID_SERNO, sizeof(serial));
-       printk(KERN_INFO "mg_disk: model: %s\n", model);
-       printk(KERN_INFO "mg_disk: firm: %.8s\n", fwrev);
-       printk(KERN_INFO "mg_disk: serial: %s\n", serial);
-       printk(KERN_INFO "mg_disk: %d + reserved %d sectors\n",
-                       host->n_sectors, host->nres_sectors);
-
-       if (!prv_data->use_polling)
-               outb(0, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-
-       return err;
-}
-
-
-static int mg_disk_init(struct mg_host *host)
-{
-       struct mg_drv_data *prv_data = host->dev->platform_data;
-       s32 err;
-       u8 init_status;
-
-       /* hdd rst low */
-       gpio_set_value(host->rst, 0);
-       err = mg_wait(host, ATA_BUSY, MG_TMAX_RST_TO_BUSY);
-       if (err)
-               return err;
-
-       /* hdd rst high */
-       gpio_set_value(host->rst, 1);
-       err = mg_wait(host, MG_STAT_READY, MG_TMAX_HDRST_TO_RDY);
-       if (err)
-               return err;
-
-       /* soft reset on */
-       outb(ATA_SRST | (prv_data->use_polling ? ATA_NIEN : 0),
-                       (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-       err = mg_wait(host, ATA_BUSY, MG_TMAX_RST_TO_BUSY);
-       if (err)
-               return err;
-
-       /* soft reset off */
-       outb(prv_data->use_polling ? ATA_NIEN : 0,
-                       (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-       err = mg_wait(host, MG_STAT_READY, MG_TMAX_SWRST_TO_RDY);
-       if (err)
-               return err;
-
-       init_status = inb((unsigned long)host->dev_base + MG_REG_STATUS) & 0xf;
-
-       if (init_status == 0xf)
-               return MG_ERR_INIT_STAT;
-
-       return err;
-}
-
-static void mg_bad_rw_intr(struct mg_host *host)
-{
-       if (host->req)
-               if (++host->req->errors >= MG_MAX_ERRORS ||
-                   host->error == MG_ERR_TIMEOUT)
-                       mg_end_request_cur(host, -EIO);
-}
-
-static unsigned int mg_out(struct mg_host *host,
-               unsigned int sect_num,
-               unsigned int sect_cnt,
-               unsigned int cmd,
-               void (*intr_addr)(struct mg_host *))
-{
-       struct mg_drv_data *prv_data = host->dev->platform_data;
-
-       if (mg_wait(host, MG_STAT_READY, MG_TMAX_CONF_TO_CMD))
-               return host->error;
-
-       if (!prv_data->use_polling) {
-               host->mg_do_intr = intr_addr;
-               mod_timer(&host->timer, jiffies + 3 * HZ);
-       }
-       if (MG_RES_SEC)
-               sect_num += MG_RES_SEC;
-       outb((u8)sect_cnt, (unsigned long)host->dev_base + MG_REG_SECT_CNT);
-       outb((u8)sect_num, (unsigned long)host->dev_base + MG_REG_SECT_NUM);
-       outb((u8)(sect_num >> 8), (unsigned long)host->dev_base +
-                       MG_REG_CYL_LOW);
-       outb((u8)(sect_num >> 16), (unsigned long)host->dev_base +
-                       MG_REG_CYL_HIGH);
-       outb((u8)((sect_num >> 24) | ATA_LBA | ATA_DEVICE_OBS),
-                       (unsigned long)host->dev_base + MG_REG_DRV_HEAD);
-       outb(cmd, (unsigned long)host->dev_base + MG_REG_COMMAND);
-       return MG_ERR_NONE;
-}
-
-static void mg_read_one(struct mg_host *host, struct request *req)
-{
-       u16 *buff = (u16 *)bio_data(req->bio);
-       u32 i;
-
-       for (i = 0; i < MG_SECTOR_SIZE >> 1; i++)
-               *buff++ = inw((unsigned long)host->dev_base + MG_BUFF_OFFSET +
-                             (i << 1));
-}
-
-static void mg_read(struct request *req)
-{
-       struct mg_host *host = req->rq_disk->private_data;
-
-       if (mg_out(host, blk_rq_pos(req), blk_rq_sectors(req),
-                  MG_CMD_RD, NULL) != MG_ERR_NONE)
-               mg_bad_rw_intr(host);
-
-       MG_DBG("requested %d sects (from %ld), buffer=0x%p\n",
-              blk_rq_sectors(req), blk_rq_pos(req), bio_data(req->bio));
-
-       do {
-               if (mg_wait(host, ATA_DRQ,
-                           MG_TMAX_WAIT_RD_DRQ) != MG_ERR_NONE) {
-                       mg_bad_rw_intr(host);
-                       return;
-               }
-
-               mg_read_one(host, req);
-
-               outb(MG_CMD_RD_CONF, (unsigned long)host->dev_base +
-                               MG_REG_COMMAND);
-       } while (mg_end_request(host, 0, MG_SECTOR_SIZE));
-}
-
-static void mg_write_one(struct mg_host *host, struct request *req)
-{
-       u16 *buff = (u16 *)bio_data(req->bio);
-       u32 i;
-
-       for (i = 0; i < MG_SECTOR_SIZE >> 1; i++)
-               outw(*buff++, (unsigned long)host->dev_base + MG_BUFF_OFFSET +
-                    (i << 1));
-}
-
-static void mg_write(struct request *req)
-{
-       struct mg_host *host = req->rq_disk->private_data;
-       unsigned int rem = blk_rq_sectors(req);
-
-       if (mg_out(host, blk_rq_pos(req), rem,
-                  MG_CMD_WR, NULL) != MG_ERR_NONE) {
-               mg_bad_rw_intr(host);
-               return;
-       }
-
-       MG_DBG("requested %d sects (from %ld), buffer=0x%p\n",
-              rem, blk_rq_pos(req), bio_data(req->bio));
-
-       if (mg_wait(host, ATA_DRQ,
-                   MG_TMAX_WAIT_WR_DRQ) != MG_ERR_NONE) {
-               mg_bad_rw_intr(host);
-               return;
-       }
-
-       do {
-               mg_write_one(host, req);
-
-               outb(MG_CMD_WR_CONF, (unsigned long)host->dev_base +
-                               MG_REG_COMMAND);
-
-               rem--;
-               if (rem > 1 && mg_wait(host, ATA_DRQ,
-                                       MG_TMAX_WAIT_WR_DRQ) != MG_ERR_NONE) {
-                       mg_bad_rw_intr(host);
-                       return;
-               } else if (mg_wait(host, MG_STAT_READY,
-                                       MG_TMAX_WAIT_WR_DRQ) != MG_ERR_NONE) {
-                       mg_bad_rw_intr(host);
-                       return;
-               }
-       } while (mg_end_request(host, 0, MG_SECTOR_SIZE));
-}
-
-static void mg_read_intr(struct mg_host *host)
-{
-       struct request *req = host->req;
-       u32 i;
-
-       /* check status */
-       do {
-               i = inb((unsigned long)host->dev_base + MG_REG_STATUS);
-               if (i & ATA_BUSY)
-                       break;
-               if (!MG_READY_OK(i))
-                       break;
-               if (i & ATA_DRQ)
-                       goto ok_to_read;
-       } while (0);
-       mg_dump_status("mg_read_intr", i, host);
-       mg_bad_rw_intr(host);
-       mg_request(host->breq);
-       return;
-
-ok_to_read:
-       mg_read_one(host, req);
-
-       MG_DBG("sector %ld, remaining=%ld, buffer=0x%p\n",
-              blk_rq_pos(req), blk_rq_sectors(req) - 1, bio_data(req->bio));
-
-       /* send read confirm */
-       outb(MG_CMD_RD_CONF, (unsigned long)host->dev_base + MG_REG_COMMAND);
-
-       if (mg_end_request(host, 0, MG_SECTOR_SIZE)) {
-               /* set handler if read remains */
-               host->mg_do_intr = mg_read_intr;
-               mod_timer(&host->timer, jiffies + 3 * HZ);
-       } else /* goto next request */
-               mg_request(host->breq);
-}
-
-static void mg_write_intr(struct mg_host *host)
-{
-       struct request *req = host->req;
-       u32 i;
-       bool rem;
-
-       /* check status */
-       do {
-               i = inb((unsigned long)host->dev_base + MG_REG_STATUS);
-               if (i & ATA_BUSY)
-                       break;
-               if (!MG_READY_OK(i))
-                       break;
-               if ((blk_rq_sectors(req) <= 1) || (i & ATA_DRQ))
-                       goto ok_to_write;
-       } while (0);
-       mg_dump_status("mg_write_intr", i, host);
-       mg_bad_rw_intr(host);
-       mg_request(host->breq);
-       return;
-
-ok_to_write:
-       if ((rem = mg_end_request(host, 0, MG_SECTOR_SIZE))) {
-               /* write 1 sector and set handler if remains */
-               mg_write_one(host, req);
-               MG_DBG("sector %ld, remaining=%ld, buffer=0x%p\n",
-                      blk_rq_pos(req), blk_rq_sectors(req), bio_data(req->bio));
-               host->mg_do_intr = mg_write_intr;
-               mod_timer(&host->timer, jiffies + 3 * HZ);
-       }
-
-       /* send write confirm */
-       outb(MG_CMD_WR_CONF, (unsigned long)host->dev_base + MG_REG_COMMAND);
-
-       if (!rem)
-               mg_request(host->breq);
-}
-
-static void mg_times_out(unsigned long data)
-{
-       struct mg_host *host = (struct mg_host *)data;
-       char *name;
-
-       spin_lock_irq(&host->lock);
-
-       if (!host->req)
-               goto out_unlock;
-
-       host->mg_do_intr = NULL;
-
-       name = host->req->rq_disk->disk_name;
-       printk(KERN_DEBUG "%s: timeout\n", name);
-
-       host->error = MG_ERR_TIMEOUT;
-       mg_bad_rw_intr(host);
-
-out_unlock:
-       mg_request(host->breq);
-       spin_unlock_irq(&host->lock);
-}
-
-static void mg_request_poll(struct request_queue *q)
-{
-       struct mg_host *host = q->queuedata;
-
-       while (1) {
-               if (!host->req) {
-                       host->req = blk_fetch_request(q);
-                       if (!host->req)
-                               break;
-               }
-
-               switch (req_op(host->req)) {
-               case REQ_OP_READ:
-                       mg_read(host->req);
-                       break;
-               case REQ_OP_WRITE:
-                       mg_write(host->req);
-                       break;
-               default:
-                       mg_end_request_cur(host, -EIO);
-                       break;
-               }
-       }
-}
-
-static unsigned int mg_issue_req(struct request *req,
-               struct mg_host *host,
-               unsigned int sect_num,
-               unsigned int sect_cnt)
-{
-       switch (req_op(host->req)) {
-       case REQ_OP_READ:
-               if (mg_out(host, sect_num, sect_cnt, MG_CMD_RD, &mg_read_intr)
-                               != MG_ERR_NONE) {
-                       mg_bad_rw_intr(host);
-                       return host->error;
-               }
-               break;
-       case REQ_OP_WRITE:
-               /* TODO : handler */
-               outb(ATA_NIEN, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-               if (mg_out(host, sect_num, sect_cnt, MG_CMD_WR, &mg_write_intr)
-                               != MG_ERR_NONE) {
-                       mg_bad_rw_intr(host);
-                       return host->error;
-               }
-               del_timer(&host->timer);
-               mg_wait(host, ATA_DRQ, MG_TMAX_WAIT_WR_DRQ);
-               outb(0, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-               if (host->error) {
-                       mg_bad_rw_intr(host);
-                       return host->error;
-               }
-               mg_write_one(host, req);
-               mod_timer(&host->timer, jiffies + 3 * HZ);
-               outb(MG_CMD_WR_CONF, (unsigned long)host->dev_base +
-                               MG_REG_COMMAND);
-               break;
-       default:
-               mg_end_request_cur(host, -EIO);
-               break;
-       }
-       return MG_ERR_NONE;
-}
-
-/* This function also called from IRQ context */
-static void mg_request(struct request_queue *q)
-{
-       struct mg_host *host = q->queuedata;
-       struct request *req;
-       u32 sect_num, sect_cnt;
-
-       while (1) {
-               if (!host->req) {
-                       host->req = blk_fetch_request(q);
-                       if (!host->req)
-                               break;
-               }
-               req = host->req;
-
-               /* check unwanted request call */
-               if (host->mg_do_intr)
-                       return;
-
-               del_timer(&host->timer);
-
-               sect_num = blk_rq_pos(req);
-               /* deal whole segments */
-               sect_cnt = blk_rq_sectors(req);
-
-               /* sanity check */
-               if (sect_num >= get_capacity(req->rq_disk) ||
-                               ((sect_num + sect_cnt) >
-                                get_capacity(req->rq_disk))) {
-                       printk(KERN_WARNING
-                                       "%s: bad access: sector=%d, count=%d\n",
-                                       req->rq_disk->disk_name,
-                                       sect_num, sect_cnt);
-                       mg_end_request_cur(host, -EIO);
-                       continue;
-               }
-
-               if (!mg_issue_req(req, host, sect_num, sect_cnt))
-                       return;
-       }
-}
-
-static int mg_getgeo(struct block_device *bdev, struct hd_geometry *geo)
-{
-       struct mg_host *host = bdev->bd_disk->private_data;
-
-       geo->cylinders = (unsigned short)host->cyls;
-       geo->heads = (unsigned char)host->heads;
-       geo->sectors = (unsigned char)host->sectors;
-       return 0;
-}
-
-static const struct block_device_operations mg_disk_ops = {
-       .getgeo = mg_getgeo
-};
-
-#ifdef CONFIG_PM_SLEEP
-static int mg_suspend(struct device *dev)
-{
-       struct mg_drv_data *prv_data = dev->platform_data;
-       struct mg_host *host = prv_data->host;
-
-       if (mg_wait(host, MG_STAT_READY, MG_TMAX_CONF_TO_CMD))
-               return -EIO;
-
-       if (!prv_data->use_polling)
-               outb(ATA_NIEN, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-
-       outb(MG_CMD_SLEEP, (unsigned long)host->dev_base + MG_REG_COMMAND);
-       /* wait until mflash deep sleep */
-       msleep(1);
-
-       if (mg_wait(host, MG_STAT_READY, MG_TMAX_CONF_TO_CMD)) {
-               if (!prv_data->use_polling)
-                       outb(0, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-               return -EIO;
-       }
-
-       return 0;
-}
-
-static int mg_resume(struct device *dev)
-{
-       struct mg_drv_data *prv_data = dev->platform_data;
-       struct mg_host *host = prv_data->host;
-
-       if (mg_wait(host, MG_STAT_READY, MG_TMAX_CONF_TO_CMD))
-               return -EIO;
-
-       outb(MG_CMD_WAKEUP, (unsigned long)host->dev_base + MG_REG_COMMAND);
-       /* wait until mflash wakeup */
-       msleep(1);
-
-       if (mg_wait(host, MG_STAT_READY, MG_TMAX_CONF_TO_CMD))
-               return -EIO;
-
-       if (!prv_data->use_polling)
-               outb(0, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-
-       return 0;
-}
-#endif
-
-static SIMPLE_DEV_PM_OPS(mg_pm, mg_suspend, mg_resume);
-
-static int mg_probe(struct platform_device *plat_dev)
-{
-       struct mg_host *host;
-       struct resource *rsc;
-       struct mg_drv_data *prv_data = plat_dev->dev.platform_data;
-       int err = 0;
-
-       if (!prv_data) {
-               printk(KERN_ERR "%s:%d fail (no driver_data)\n",
-                               __func__, __LINE__);
-               err = -EINVAL;
-               goto probe_err;
-       }
-
-       /* alloc mg_host */
-       host = kzalloc(sizeof(struct mg_host), GFP_KERNEL);
-       if (!host) {
-               printk(KERN_ERR "%s:%d fail (no memory for mg_host)\n",
-                               __func__, __LINE__);
-               err = -ENOMEM;
-               goto probe_err;
-       }
-       host->major = MG_DISK_MAJ;
-
-       /* link each other */
-       prv_data->host = host;
-       host->dev = &plat_dev->dev;
-
-       /* io remap */
-       rsc = platform_get_resource(plat_dev, IORESOURCE_MEM, 0);
-       if (!rsc) {
-               printk(KERN_ERR "%s:%d platform_get_resource fail\n",
-                               __func__, __LINE__);
-               err = -EINVAL;
-               goto probe_err_2;
-       }
-       host->dev_base = ioremap(rsc->start, resource_size(rsc));
-       if (!host->dev_base) {
-               printk(KERN_ERR "%s:%d ioremap fail\n",
-                               __func__, __LINE__);
-               err = -EIO;
-               goto probe_err_2;
-       }
-       MG_DBG("dev_base = 0x%x\n", (u32)host->dev_base);
-
-       /* get reset pin */
-       rsc = platform_get_resource_byname(plat_dev, IORESOURCE_IO,
-                       MG_RST_PIN);
-       if (!rsc) {
-               printk(KERN_ERR "%s:%d get reset pin fail\n",
-                               __func__, __LINE__);
-               err = -EIO;
-               goto probe_err_3;
-       }
-       host->rst = rsc->start;
-
-       /* init rst pin */
-       err = gpio_request(host->rst, MG_RST_PIN);
-       if (err)
-               goto probe_err_3;
-       gpio_direction_output(host->rst, 1);
-
-       /* reset out pin */
-       if (!(prv_data->dev_attr & MG_DEV_MASK)) {
-               err = -EINVAL;
-               goto probe_err_3a;
-       }
-
-       if (prv_data->dev_attr != MG_BOOT_DEV) {
-               rsc = platform_get_resource_byname(plat_dev, IORESOURCE_IO,
-                               MG_RSTOUT_PIN);
-               if (!rsc) {
-                       printk(KERN_ERR "%s:%d get reset-out pin fail\n",
-                                       __func__, __LINE__);
-                       err = -EIO;
-                       goto probe_err_3a;
-               }
-               host->rstout = rsc->start;
-               err = gpio_request(host->rstout, MG_RSTOUT_PIN);
-               if (err)
-                       goto probe_err_3a;
-               gpio_direction_input(host->rstout);
-       }
-
-       /* disk reset */
-       if (prv_data->dev_attr == MG_STORAGE_DEV) {
-               /* If POR seq. not yet finished, wait */
-               err = mg_wait_rstout(host->rstout, MG_TMAX_RSTOUT);
-               if (err)
-                       goto probe_err_3b;
-               err = mg_disk_init(host);
-               if (err) {
-                       printk(KERN_ERR "%s:%d fail (err code : %d)\n",
-                                       __func__, __LINE__, err);
-                       err = -EIO;
-                       goto probe_err_3b;
-               }
-       }
-
-       /* get irq resource */
-       if (!prv_data->use_polling) {
-               host->irq = platform_get_irq(plat_dev, 0);
-               if (host->irq == -ENXIO) {
-                       err = host->irq;
-                       goto probe_err_3b;
-               }
-               err = request_irq(host->irq, mg_irq,
-                               IRQF_TRIGGER_RISING,
-                               MG_DEV_NAME, host);
-               if (err) {
-                       printk(KERN_ERR "%s:%d fail (request_irq err=%d)\n",
-                                       __func__, __LINE__, err);
-                       goto probe_err_3b;
-               }
-
-       }
-
-       /* get disk id */
-       err = mg_get_disk_id(host);
-       if (err) {
-               printk(KERN_ERR "%s:%d fail (err code : %d)\n",
-                               __func__, __LINE__, err);
-               err = -EIO;
-               goto probe_err_4;
-       }
-
-       err = register_blkdev(host->major, MG_DISK_NAME);
-       if (err < 0) {
-               printk(KERN_ERR "%s:%d register_blkdev fail (err code : %d)\n",
-                               __func__, __LINE__, err);
-               goto probe_err_4;
-       }
-       if (!host->major)
-               host->major = err;
-
-       spin_lock_init(&host->lock);
-
-       if (prv_data->use_polling)
-               host->breq = blk_init_queue(mg_request_poll, &host->lock);
-       else
-               host->breq = blk_init_queue(mg_request, &host->lock);
-
-       if (!host->breq) {
-               err = -ENOMEM;
-               printk(KERN_ERR "%s:%d (blk_init_queue) fail\n",
-                               __func__, __LINE__);
-               goto probe_err_5;
-       }
-       host->breq->queuedata = host;
-
-       /* mflash is random device, thanx for the noop */
-       err = elevator_change(host->breq, "noop");
-       if (err) {
-               printk(KERN_ERR "%s:%d (elevator_init) fail\n",
-                               __func__, __LINE__);
-               goto probe_err_6;
-       }
-       blk_queue_max_hw_sectors(host->breq, MG_MAX_SECTS);
-       blk_queue_logical_block_size(host->breq, MG_SECTOR_SIZE);
-
-       setup_timer(&host->timer, mg_times_out, (unsigned long)host);
-
-       host->gd = alloc_disk(MG_DISK_MAX_PART);
-       if (!host->gd) {
-               printk(KERN_ERR "%s:%d (alloc_disk) fail\n",
-                               __func__, __LINE__);
-               err = -ENOMEM;
-               goto probe_err_7;
-       }
-       host->gd->major = host->major;
-       host->gd->first_minor = 0;
-       host->gd->fops = &mg_disk_ops;
-       host->gd->queue = host->breq;
-       host->gd->private_data = host;
-       sprintf(host->gd->disk_name, MG_DISK_NAME"a");
-
-       set_capacity(host->gd, host->n_sectors);
-
-       add_disk(host->gd);
-
-       return err;
-
-probe_err_7:
-       del_timer_sync(&host->timer);
-probe_err_6:
-       blk_cleanup_queue(host->breq);
-probe_err_5:
-       unregister_blkdev(host->major, MG_DISK_NAME);
-probe_err_4:
-       if (!prv_data->use_polling)
-               free_irq(host->irq, host);
-probe_err_3b:
-       gpio_free(host->rstout);
-probe_err_3a:
-       gpio_free(host->rst);
-probe_err_3:
-       iounmap(host->dev_base);
-probe_err_2:
-       kfree(host);
-probe_err:
-       return err;
-}
-
-static int mg_remove(struct platform_device *plat_dev)
-{
-       struct mg_drv_data *prv_data = plat_dev->dev.platform_data;
-       struct mg_host *host = prv_data->host;
-       int err = 0;
-
-       /* delete timer */
-       del_timer_sync(&host->timer);
-
-       /* remove disk */
-       if (host->gd) {
-               del_gendisk(host->gd);
-               put_disk(host->gd);
-       }
-       /* remove queue */
-       if (host->breq)
-               blk_cleanup_queue(host->breq);
-
-       /* unregister blk device */
-       unregister_blkdev(host->major, MG_DISK_NAME);
-
-       /* free irq */
-       if (!prv_data->use_polling)
-               free_irq(host->irq, host);
-
-       /* free reset-out pin */
-       if (prv_data->dev_attr != MG_BOOT_DEV)
-               gpio_free(host->rstout);
-
-       /* free rst pin */
-       if (host->rst)
-               gpio_free(host->rst);
-
-       /* unmap io */
-       if (host->dev_base)
-               iounmap(host->dev_base);
-
-       /* free mg_host */
-       kfree(host);
-
-       return err;
-}
-
-static struct platform_driver mg_disk_driver = {
-       .probe = mg_probe,
-       .remove = mg_remove,
-       .driver = {
-               .name = MG_DEV_NAME,
-               .pm = &mg_pm,
-       }
-};
-
-/****************************************************************************
- *
- * Module stuff
- *
- ****************************************************************************/
-
-static int __init mg_init(void)
-{
-       printk(KERN_INFO "mGine mflash driver, (c) 2008 mGine Co.\n");
-       return platform_driver_register(&mg_disk_driver);
-}
-
-static void __exit mg_exit(void)
-{
-       printk(KERN_INFO "mflash driver : bye bye\n");
-       platform_driver_unregister(&mg_disk_driver);
-}
-
-module_init(mg_init);
-module_exit(mg_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("unsik Kim <donari75@gmail.com>");
-MODULE_DESCRIPTION("mGine m[g]flash device driver");
diff --git a/include/linux/mg_disk.h b/include/linux/mg_disk.h
deleted file mode 100644 (file)
index e11f4d9..0000000
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- *  include/linux/mg_disk.c
- *
- *  Private data for mflash platform driver
- *
- * (c) 2008 mGine Co.,LTD
- * (c) 2008 unsik Kim <donari75@gmail.com>
- *
- *  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.
- */
-
-#ifndef __MG_DISK_H__
-#define __MG_DISK_H__
-
-/* name for platform device */
-#define MG_DEV_NAME "mg_disk"
-
-/* names of GPIO resource */
-#define MG_RST_PIN     "mg_rst"
-/* except MG_BOOT_DEV, reset-out pin should be assigned */
-#define MG_RSTOUT_PIN  "mg_rstout"
-
-/* device attribution */
-/* use mflash as boot device */
-#define MG_BOOT_DEV            (1 << 0)
-/* use mflash as storage device */
-#define MG_STORAGE_DEV         (1 << 1)
-/* same as MG_STORAGE_DEV, but bootloader already done reset sequence */
-#define MG_STORAGE_DEV_SKIP_RST        (1 << 2)
-
-/* private driver data */
-struct mg_drv_data {
-       /* disk resource */
-       u32 use_polling;
-
-       /* device attribution */
-       u32 dev_attr;
-
-       /* internally used */
-       void *host;
-};
-
-#endif