HYL_OK3568_LINUX/kernel-rt/drivers/rk_nand/rk_nand_blk.c

/*
 * Copyright (c) 2016, Fuzhou Rockchip Electronics Co., Ltd
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/list.h>
#include <linux/fs.h>
#include <linux/blkdev.h>
#include <linux/blkpg.h>
#include <linux/spinlock.h>
#include <linux/hdreg.h>
#include <linux/init.h>
#include <linux/semaphore.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/timer.h>
#include <linux/delay.h>
#include <linux/clk.h>
#include <linux/mutex.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/freezer.h>
#include <linux/kthread.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/version.h>
#include <linux/soc/rockchip/rk_vendor_storage.h>

#include "rk_nand_blk.h"
#include "rk_ftl_api.h"

static struct nand_part disk_array[MAX_PART_COUNT];
static int g_max_part_num = 4;

#define PART_READONLY 0x85
#define PART_WRITEONLY 0x86
#define PART_NO_ACCESS 0x87

static unsigned long totle_read_data;
static unsigned long totle_write_data;
static unsigned long totle_read_count;
static unsigned long totle_write_count;
static int rk_nand_dev_initialised;

static char *mtd_read_temp_buffer;
#define MTD_RW_SECTORS (512)

static int rknand_proc_show(struct seq_file *m, void *v)
{
	m->count = rknand_proc_ftlread(m->buf);
	seq_printf(m, "Totle Read %ld KB\n", totle_read_data >> 1);
	seq_printf(m, "Totle Write %ld KB\n", totle_write_data >> 1);
	seq_printf(m, "totle_write_count %ld\n", totle_write_count);
	seq_printf(m, "totle_read_count %ld\n", totle_read_count);
	return 0;
}

static int rknand_mtd_proc_show(struct seq_file *m, void *v)
{
	int i;

	seq_printf(m, "%s", "dev:    size   erasesize  name\n");
	for (i = 0; i < g_max_part_num; i++) {
		seq_printf(m, "rknand%d: %8.8llx %8.8x \"%s\"\n", i,
			   (unsigned long long)disk_array[i].size * 512,
			   32 * 0x200, disk_array[i].name);
	}
	return 0;
}

static int rknand_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, rknand_proc_show, PDE_DATA(inode));
}

static int rknand_mtd_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, rknand_mtd_proc_show, PDE_DATA(inode));
}

static const struct file_operations rknand_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= rknand_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static const struct file_operations rknand_mtd_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= rknand_mtd_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static int rknand_create_procfs(void)
{
	struct proc_dir_entry *ent;

	ent = proc_create_data("rknand", 0444, NULL, &rknand_proc_fops,
			       (void *)0);
	if (!ent)
		return -1;

	ent = proc_create_data("mtd", 0444, NULL, &rknand_mtd_proc_fops,
			       (void *)0);
	if (!ent)
		return -1;
	return 0;
}

static struct mutex g_rk_nand_ops_mutex;

static void rknand_device_lock_init(void)
{
	mutex_init(&g_rk_nand_ops_mutex);
}

void rknand_device_lock(void)
{
	mutex_lock(&g_rk_nand_ops_mutex);
}

int rknand_device_trylock(void)
{
	return mutex_trylock(&g_rk_nand_ops_mutex);
}

void rknand_device_unlock(void)
{
	mutex_unlock(&g_rk_nand_ops_mutex);
}

static int nand_dev_transfer(struct nand_blk_dev *dev,
			     unsigned long start,
			     unsigned long nsector,
			     char *buf,
			     int cmd,
			     int totle_nsec)
{
	int ret;

	if (dev->disable_access ||
	    ((cmd == WRITE) && dev->readonly) ||
	    ((cmd == READ) && dev->writeonly)) {
		return BLK_STS_IOERR;
	}

	start += dev->off_size;
	rknand_device_lock();

	switch (cmd) {
	case READ:
		totle_read_data += nsector;
		totle_read_count++;
		ret = FtlRead(0, start, nsector, buf);
		if (ret)
			ret = BLK_STS_IOERR;
		break;

	case WRITE:
		totle_write_data += nsector;
		totle_write_count++;
		ret = FtlWrite(0, start, nsector, buf);
		if (ret)
			ret = BLK_STS_IOERR;
		break;

	default:
		ret = BLK_STS_IOERR;
		break;
	}

	rknand_device_unlock();
	return ret;
}

static DECLARE_WAIT_QUEUE_HEAD(rknand_thread_wait);
static void rk_ftl_gc_timeout_hack(struct timer_list *unused);
static DEFINE_TIMER(rk_ftl_gc_timeout, rk_ftl_gc_timeout_hack);
static unsigned long rk_ftl_gc_jiffies;
static unsigned long rk_ftl_gc_do;

static void rk_ftl_gc_timeout_hack(struct timer_list *unused)
{
	del_timer(&rk_ftl_gc_timeout);
	rk_ftl_gc_do++;
	rk_ftl_gc_timeout.expires = jiffies + rk_ftl_gc_jiffies * rk_ftl_gc_do;
	add_timer(&rk_ftl_gc_timeout);
}

static int req_check_buffer_align(struct request *req, char **pbuf)
{
	int nr_vec = 0;
	struct bio_vec bv;
	struct req_iterator iter;
	char *buffer;
	void *firstbuf = 0;
	char *nextbuffer = 0;

	rq_for_each_segment(bv, req, iter) {
		/* high mem return 0 and using kernel buffer */
		if (PageHighMem(bv.bv_page))
			return 0;

		buffer = page_address(bv.bv_page) + bv.bv_offset;
		if (!buffer)
			return 0;
		if (!firstbuf)
			firstbuf = buffer;
		nr_vec++;
		if (nextbuffer && nextbuffer != buffer)
			return 0;
		nextbuffer = buffer + bv.bv_len;
	}
	*pbuf = firstbuf;
	return 1;
}

static int nand_blktrans_thread(void *arg)
{
	struct nand_blk_ops *nandr = arg;
	struct request_queue *rq = nandr->rq;
	struct request *req = NULL;
	int ftl_gc_status = 0;
	char *buf, *page_buf;
	struct req_iterator rq_iter;
	struct bio_vec bvec;
	unsigned long long sector_index = ULLONG_MAX;
	unsigned long totle_nsect;
	int rw_flag = 0;
	int req_empty_times = 0;
	int op;

	spin_lock_irq(rq->queue_lock);
	rk_ftl_gc_jiffies = HZ / 10; /* do garbage collect after 100ms */
	rk_ftl_gc_do = 0;
	rk_ftl_gc_timeout.expires = jiffies + rk_ftl_gc_jiffies;
	add_timer(&rk_ftl_gc_timeout);

	while (!nandr->quit) {
		int res;
		struct nand_blk_dev *dev;
		DECLARE_WAITQUEUE(wait, current);

		if (!req)
			req = blk_fetch_request(rq);
		if (!req) {
			add_wait_queue(&nandr->thread_wq, &wait);
			set_current_state(TASK_INTERRUPTIBLE);
			spin_unlock_irq(rq->queue_lock);
			if (rknand_device_trylock()) {
				ftl_gc_status = rk_ftl_garbage_collect(1, 0);
				rknand_device_unlock();
				rk_ftl_gc_jiffies = HZ / 50;
				if (ftl_gc_status == 0)
					rk_ftl_gc_jiffies = 1 * HZ;

			} else {
				rk_ftl_gc_jiffies = HZ / 50;
			}
			req_empty_times++;
			if (req_empty_times < 10)
				rk_ftl_gc_jiffies = HZ / 50;
			/* 100ms cache write back */
			if (req_empty_times >= 5 && req_empty_times < 7) {
				rknand_device_lock();
				rk_ftl_cache_write_back();
				rknand_device_unlock();
			}
			wait_event_timeout(nandr->thread_wq,
					   rk_ftl_gc_do || nandr->quit,
					   rk_ftl_gc_jiffies);
			rk_ftl_gc_do = 0;
			spin_lock_irq(rq->queue_lock);
			remove_wait_queue(&nandr->thread_wq, &wait);
			continue;
		} else {
			rk_ftl_gc_jiffies = 1 * HZ;
			req_empty_times = 0;
		}

		dev = req->rq_disk->private_data;
		totle_nsect = (req->__data_len) >> 9;
		sector_index = blk_rq_pos(req);
		buf = 0;
		res = 0;

		op = req_op(req);
		if (op == REQ_OP_DISCARD) {
			spin_unlock_irq(rq->queue_lock);
			rknand_device_lock();
			if (FtlDiscard(blk_rq_pos(req) +
				       dev->off_size, totle_nsect))
				res = BLK_STS_IOERR;
			rknand_device_unlock();
			spin_lock_irq(rq->queue_lock);
			if (!__blk_end_request_cur(req, res))
				req = NULL;
			continue;
		} else if (op == REQ_OP_FLUSH) {
			spin_unlock_irq(rq->queue_lock);
			rknand_device_lock();
			rk_ftl_cache_write_back();
			rknand_device_unlock();
			spin_lock_irq(rq->queue_lock);
			if (!__blk_end_request_cur(req, res))
				req = NULL;
			continue;
		} else if (op == REQ_OP_READ) {
			rw_flag = READ;
		} else if (op == REQ_OP_WRITE) {
			rw_flag = WRITE;
		} else {
			__blk_end_request_all(req, BLK_STS_IOERR);
			req = NULL;
			continue;
		}

		if (mtd_read_temp_buffer) {
			buf = mtd_read_temp_buffer;
			req_check_buffer_align(req, &buf);

			if (rw_flag == WRITE && buf == mtd_read_temp_buffer) {
				char *p = buf;

				rq_for_each_segment(bvec, req, rq_iter) {
					page_buf = kmap_atomic(bvec.bv_page);
					memcpy(p,
					       page_buf + bvec.bv_offset,
					       bvec.bv_len);
					p += bvec.bv_len;
					kunmap_atomic(page_buf);
				}
			}

			spin_unlock_irq(rq->queue_lock);
			res = nand_dev_transfer(dev,
						sector_index,
						totle_nsect,
						buf,
						rw_flag,
						totle_nsect);
			spin_lock_irq(rq->queue_lock);

			if (rw_flag == READ && buf == mtd_read_temp_buffer) {
				char *p = buf;

				rq_for_each_segment(bvec, req, rq_iter) {
					page_buf = kmap_atomic(bvec.bv_page);

					memcpy(page_buf + bvec.bv_offset,
					       p,
					       bvec.bv_len);
					p += bvec.bv_len;
					kunmap_atomic(page_buf);
				}
			}
			__blk_end_request_all(req, res);
			req = NULL;
		} else {
			while (req) {
				sector_index = blk_rq_pos(req);
				totle_nsect = blk_rq_cur_bytes(req);
				buf = kmap_atomic(bio_page(req->bio)) +
					   bio_offset(req->bio);
				spin_unlock_irq(rq->queue_lock);
				res = nand_dev_transfer(dev,
							sector_index,
							totle_nsect,
							buf,
							rw_flag,
							totle_nsect);
				spin_lock_irq(rq->queue_lock);
				kunmap_atomic(buf);
				if (!__blk_end_request_cur(req, res))
					req = NULL;
			}
		}
	}
	pr_info("nand th quited\n");
	nandr->nand_th_quited = 1;
	if (req)
		__blk_end_request_all(req, BLK_STS_IOERR);
	rk_nand_schedule_enable_config(0);
	while ((req = blk_fetch_request(rq)) != NULL)
		__blk_end_request_all(req, BLK_STS_IOERR);
	spin_unlock_irq(rq->queue_lock);
	complete_and_exit(&nandr->thread_exit, 0);
	return 0;
}

static void nand_blk_request(struct request_queue *rq)
{
	struct nand_blk_ops *nandr = rq->queuedata;
	struct request *req = NULL;

	if (nandr->nand_th_quited) {
		while ((req = blk_fetch_request(rq)) != NULL)
			__blk_end_request_all(req, BLK_STS_IOERR);
		return;
	}
	rk_ftl_gc_do = 1;
	wake_up(&nandr->thread_wq);
}

static int rknand_get_part(char *parts,
			   struct nand_part *this_part,
			   int *part_index)
{
	char delim;
	unsigned int mask_flags;
	unsigned long long size, offset = ULLONG_MAX;
	char name[40] = "\0";

	if (*parts == '-') {
		size = ULLONG_MAX;
		parts++;
	} else {
		size = memparse(parts, &parts);
	}

	if (*parts == '@') {
		parts++;
		offset = memparse(parts, &parts);
	}

	mask_flags = 0;
	delim = 0;

	if (*parts == '(')
		delim = ')';

	if (delim) {
		char *p;

		p = strchr(parts + 1, delim);
		if (!p)
			return 0;
		strncpy(name, parts + 1, p - (parts + 1));
		parts = p + 1;
	}

	if (strncmp(parts, "ro", 2) == 0) {
		mask_flags = PART_READONLY;
		parts += 2;
	}

	if (strncmp(parts, "wo", 2) == 0) {
		mask_flags = PART_WRITEONLY;
		parts += 2;
	}

	this_part->size = (unsigned long)size;
	this_part->offset = (unsigned long)offset;
	this_part->type = mask_flags;
	sprintf(this_part->name, "%s", name);

	if ((++(*part_index) < MAX_PART_COUNT) && (*parts == ','))
		rknand_get_part(++parts, this_part + 1, part_index);

	return 1;
}

static int nand_prase_cmdline_part(struct nand_part *pdisk_part)
{
	char *pbuf;
	int part_num = 0, i;
	unsigned int cap_size = rk_ftl_get_capacity();
	char *cmdline;

	cmdline = strstr(saved_command_line, "mtdparts=");
	if (!cmdline)
		return 0;
	cmdline += 9;
	if (!memcmp(cmdline, "rk29xxnand:", strlen("rk29xxnand:"))) {
		pbuf = cmdline + strlen("rk29xxnand:");
		rknand_get_part(pbuf, pdisk_part, &part_num);
		if (part_num)
			pdisk_part[part_num - 1].size = cap_size -
				pdisk_part[part_num - 1].offset;

		for (i = 0; i < part_num; i++) {
			if (pdisk_part[i].size + pdisk_part[i].offset
				> cap_size) {
				pdisk_part[i].size = cap_size -
					pdisk_part[i].offset;
				pr_err("partition error....max cap:%x\n",
					cap_size);
				if (!pdisk_part[i].size)
					return i;
				else
					return (i + 1);
			}
		}
		return part_num;
	}
	return 0;
}

static int rknand_open(struct block_device *bdev, fmode_t mode)
{
	return 0;
}

static void rknand_release(struct gendisk *disk, fmode_t mode)
{
};

#define DISABLE_WRITE _IO('V', 0)
#define ENABLE_WRITE _IO('V', 1)
#define DISABLE_READ _IO('V', 2)
#define ENABLE_READ _IO('V', 3)
static int rknand_ioctl(struct block_device *bdev, fmode_t mode,
			unsigned int cmd,
			unsigned long arg)
{
	struct nand_blk_dev *dev = bdev->bd_disk->private_data;

	switch (cmd) {
	case ENABLE_WRITE:
		dev->disable_access = 0;
		dev->readonly = 0;
		set_disk_ro(dev->blkcore_priv, 0);
		return 0;

	case DISABLE_WRITE:
		dev->readonly = 1;
		set_disk_ro(dev->blkcore_priv, 1);
		return 0;

	case ENABLE_READ:
		dev->disable_access = 0;
		dev->writeonly = 0;
		return 0;

	case DISABLE_READ:
		dev->writeonly = 1;
		return 0;
	default:
		return -ENOTTY;
	}
}

const struct block_device_operations nand_blktrans_ops = {
	.owner = THIS_MODULE,
	.open = rknand_open,
	.release = rknand_release,
	.ioctl = rknand_ioctl,
};

static struct nand_blk_ops mytr = {
	.name =  "rknand",
	.major = 31,
	.minorbits = 0,
	.owner = THIS_MODULE,
};

static int nand_add_dev(struct nand_blk_ops *nandr, struct nand_part *part)
{
	struct nand_blk_dev *dev;
	struct gendisk *gd;

	if (part->size == 0)
		return -1;

	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (!dev)
		return -ENOMEM;

	gd = alloc_disk(1 << nandr->minorbits);
	if (!gd) {
		kfree(dev);
		return -ENOMEM;
	}

	dev->nandr = nandr;
	dev->size = part->size;
	dev->off_size = part->offset;
	dev->devnum = nandr->last_dev_index;
	list_add_tail(&dev->list, &nandr->devs);
	nandr->last_dev_index++;

	gd->major = nandr->major;
	gd->first_minor = (dev->devnum) << nandr->minorbits;

	gd->fops = &nand_blktrans_ops;

	if (part->name[0]) {
		snprintf(gd->disk_name,
			 sizeof(gd->disk_name),
			 "%s_%s",
			 nandr->name,
			 part->name);
	} else {
		gd->flags = GENHD_FL_EXT_DEVT;
		gd->minors = 255;
		snprintf(gd->disk_name,
			 sizeof(gd->disk_name),
			 "%s%d",
			 nandr->name,
			 dev->devnum);
	}
	set_capacity(gd, dev->size);

	gd->private_data = dev;
	dev->blkcore_priv = gd;
	gd->queue = nandr->rq;
	gd->queue->bypass_depth = 1;

	if (part->type == PART_NO_ACCESS)
		dev->disable_access = 1;

	if (part->type == PART_READONLY)
		dev->readonly = 1;

	if (part->type == PART_WRITEONLY)
		dev->writeonly = 1;

	if (dev->readonly)
		set_disk_ro(gd, 1);

	if (gd->flags != GENHD_FL_EXT_DEVT)
		add_disk(gd);
	else
		device_add_disk(g_nand_device, gd);

	return 0;
}

static int nand_remove_dev(struct nand_blk_dev *dev)
{
	struct gendisk *gd;

	gd = dev->blkcore_priv;
	list_del(&dev->list);
	gd->queue = NULL;
	del_gendisk(gd);
	put_disk(gd);
	kfree(dev);
	return 0;
}

int nand_blk_add_whole_disk(void)
{
	struct nand_part part;

	part.offset = 0;
	part.size = rk_ftl_get_capacity();
	part.type = 0;
	strncpy(part.name, "rknand", sizeof(part.name));
	nand_add_dev(&mytr, &part);
	return 0;
}

static int nand_blk_register(struct nand_blk_ops *nandr)
{
	int i, ret;
	u32 part_size;
	struct nand_part part;

	rk_nand_schedule_enable_config(1);
	nandr->quit = 0;
	nandr->nand_th_quited = 0;

	mtd_read_temp_buffer = kmalloc(MTD_RW_SECTORS * 512,
				       GFP_KERNEL | GFP_DMA);

	ret = register_blkdev(nandr->major, nandr->name);
	if (ret)
		return -1;

	spin_lock_init(&nandr->queue_lock);
	init_completion(&nandr->thread_exit);
	init_waitqueue_head(&nandr->thread_wq);
	rknand_device_lock_init();

	nandr->rq = blk_init_queue(nand_blk_request, &nandr->queue_lock);
	if (!nandr->rq) {
		unregister_blkdev(nandr->major, nandr->name);
		return  -1;
	}

	blk_queue_max_hw_sectors(nandr->rq, MTD_RW_SECTORS);
	blk_queue_max_segments(nandr->rq, MTD_RW_SECTORS);

	blk_queue_flag_set(QUEUE_FLAG_DISCARD, nandr->rq);
	blk_queue_max_discard_sectors(nandr->rq, UINT_MAX >> 9);
	/* discard_granularity config to one nand page size 32KB*/
	nandr->rq->limits.discard_granularity = 64 << 9;

	nandr->rq->queuedata = nandr;
	INIT_LIST_HEAD(&nandr->devs);
	kthread_run(nand_blktrans_thread, (void *)nandr, "rknand");

	g_max_part_num = nand_prase_cmdline_part(disk_array);

	nandr->last_dev_index = 0;
	part.offset = 0;
	part.size = rk_ftl_get_capacity();
	part.type = 0;
	part.name[0] = 0;
	nand_add_dev(&mytr, &part);

	if (g_max_part_num) {
		for (i = 0; i < g_max_part_num; i++) {
			part_size = (disk_array[i].offset + disk_array[i].size);
			pr_info("%10s: 0x%09llx -- 0x%09llx (%llu MB)\n",
				disk_array[i].name,
				(u64)disk_array[i].offset * 512,
				(u64)part_size * 512,
				(u64)disk_array[i].size / 2048);
			nand_add_dev(nandr, &disk_array[i]);
		}
	}

	rknand_create_procfs();
	rk_ftl_storage_sys_init();

	ret = rk_ftl_vendor_storage_init();
	if (!ret) {
		rk_vendor_register(rk_ftl_vendor_read, rk_ftl_vendor_write);
		rknand_vendor_storage_init();
		pr_info("rknand vendor storage init ok !\n");
	} else {
		pr_info("rknand vendor storage init failed !\n");
	}

	return 0;
}

static void nand_blk_unregister(struct nand_blk_ops *nandr)
{
	struct list_head *this, *next;

	if (!rk_nand_dev_initialised)
		return;
	nandr->quit = 1;
	wake_up(&nandr->thread_wq);
	wait_for_completion(&nandr->thread_exit);
	list_for_each_safe(this, next, &nandr->devs) {
		struct nand_blk_dev *dev
			= list_entry(this, struct nand_blk_dev, list);

		nand_remove_dev(dev);
	}
	blk_cleanup_queue(nandr->rq);
	unregister_blkdev(nandr->major, nandr->name);
}

void rknand_dev_flush(void)
{
	if (!rk_nand_dev_initialised)
		return;
	rknand_device_lock();
	rk_ftl_cache_write_back();
	rknand_device_unlock();
	pr_info("Nand flash flush ok!\n");
}

int __init rknand_dev_init(void)
{
	int ret;
	void __iomem *nandc0;
	void __iomem *nandc1;

	rknand_get_reg_addr((unsigned long *)&nandc0, (unsigned long *)&nandc1);
	if (!nandc0)
		return -1;

	ret = rk_ftl_init();
	if (ret) {
		pr_err("rk_ftl_init fail\n");
		return -1;
	}

	ret = nand_blk_register(&mytr);
	if (ret) {
		pr_err("nand_blk_register fail\n");
		return -1;
	}

	rk_nand_dev_initialised = 1;
	return ret;
}

int rknand_dev_exit(void)
{
	if (!rk_nand_dev_initialised)
		return -1;
	rk_nand_dev_initialised = 0;
	if (rknand_device_trylock()) {
		rk_ftl_cache_write_back();
		rknand_device_unlock();
	}
	nand_blk_unregister(&mytr);
	rk_ftl_de_init();
	pr_info("nand_blk_dev_exit:OK\n");
	return 0;
}

void rknand_dev_suspend(void)
{
	if (!rk_nand_dev_initialised)
		return;
	pr_info("rk_nand_suspend\n");
	rk_nand_schedule_enable_config(0);
	rknand_device_lock();
	rk_nand_suspend();
}

void rknand_dev_resume(void)
{
	if (!rk_nand_dev_initialised)
		return;
	pr_info("rk_nand_resume\n");
	rk_nand_resume();
	rknand_device_unlock();
	rk_nand_schedule_enable_config(1);
}

void rknand_dev_shutdown(void)
{
	pr_info("rknand_shutdown...\n");
	if (!rk_nand_dev_initialised)
		return;
	if (mytr.quit == 0) {
		mytr.quit = 1;
		wake_up(&mytr.thread_wq);
		wait_for_completion(&mytr.thread_exit);
		rk_ftl_de_init();
	}
	pr_info("rknand_shutdown:OK\n");
}