Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6a5d2638 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.dk/linux-2.6-block 

* 'for-linus' of git://git.kernel.dk/linux-2.6-block:
  loop: mutex already unlocked in loop_clr_fd()
  cfq-iosched: don't let idling interfere with plugging
  block: remove unused REQ_UNPLUG
  cfq-iosched: kill two unused cfqq flags
  cfq-iosched: change dispatch logic to deal with single requests at the time
  mflash: initial support
  cciss: change to discover first memory BAR
  cciss: kernel scan thread for MSA2012
  cciss: fix residual count for block pc requests
  block: fix inconsistency in I/O stat accounting code
  block: elevator quiescing helpers
parents aeeae868 ffcd7dca

Documentation/blockdev/00-INDEX

+2 −0
Original line number Diff line number Diff line
@@ -8,6 +8,8 @@ cpqarray.txt 
	- info on using Compaq's SMART2 Intelligent Disk Array Controllers.

floppy.txt

	- notes and driver options for the floppy disk driver.

mflash.txt

	- info on mGine m(g)flash driver for linux.

nbd.txt

	- info on a TCP implementation of a network block device.

paride.txt

Documentation/blockdev/mflash.txt

0 → 100644
+84 −0
Original line number Diff line number Diff line 
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.



Followings 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);

block/blk-core.c

+4 −11
Original line number Diff line number Diff line
@@ -64,12 +64,11 @@ static struct workqueue_struct *kblockd_workqueue; 


static void drive_stat_acct(struct request *rq, int new_io)

{

	struct gendisk *disk = rq->rq_disk;

	struct hd_struct *part;

	int rw = rq_data_dir(rq);

	int cpu;



	if (!blk_fs_request(rq) || !disk || !blk_do_io_stat(disk->queue))

	if (!blk_fs_request(rq) || !blk_do_io_stat(rq))

		return;



	cpu = part_stat_lock();
@@ -1124,8 +1123,6 @@ void init_request_from_bio(struct request *req, struct bio *bio) 


	if (bio_sync(bio))

		req->cmd_flags |= REQ_RW_SYNC;

	if (bio_unplug(bio))

		req->cmd_flags |= REQ_UNPLUG;

	if (bio_rw_meta(bio))

		req->cmd_flags |= REQ_RW_META;

	if (bio_noidle(bio))
@@ -1675,9 +1672,7 @@ EXPORT_SYMBOL(blkdev_dequeue_request); 


static void blk_account_io_completion(struct request *req, unsigned int bytes)

{

	struct gendisk *disk = req->rq_disk;



	if (!disk || !blk_do_io_stat(disk->queue))

	if (!blk_do_io_stat(req))

		return;



	if (blk_fs_request(req)) {
@@ -1694,9 +1689,7 @@ static void blk_account_io_completion(struct request *req, unsigned int bytes) 


static void blk_account_io_done(struct request *req)

{

	struct gendisk *disk = req->rq_disk;



	if (!disk || !blk_do_io_stat(disk->queue))

	if (!blk_do_io_stat(req))

		return;



	/*
@@ -1711,7 +1704,7 @@ static void blk_account_io_done(struct request *req) 
		int cpu;



		cpu = part_stat_lock();

		part = disk_map_sector_rcu(disk, req->sector);

		part = disk_map_sector_rcu(req->rq_disk, req->sector);



		part_stat_inc(cpu, part, ios[rw]);

		part_stat_add(cpu, part, ticks[rw], duration);

block/blk-merge.c

+17 −12
Original line number Diff line number Diff line
@@ -338,6 +338,22 @@ static int ll_merge_requests_fn(struct request_queue *q, struct request *req, 
	return 1;

}



static void blk_account_io_merge(struct request *req)

{

	if (blk_do_io_stat(req)) {

		struct hd_struct *part;

		int cpu;



		cpu = part_stat_lock();

		part = disk_map_sector_rcu(req->rq_disk, req->sector);



		part_round_stats(cpu, part);

		part_dec_in_flight(part);



		part_stat_unlock();

	}

}



/*

 * Has to be called with the request spinlock acquired

 */
@@ -386,18 +402,7 @@ static int attempt_merge(struct request_queue *q, struct request *req, 


	elv_merge_requests(q, req, next);



	if (req->rq_disk) {

		struct hd_struct *part;

		int cpu;



		cpu = part_stat_lock();

		part = disk_map_sector_rcu(req->rq_disk, req->sector);



		part_round_stats(cpu, part);

		part_dec_in_flight(part);



		part_stat_unlock();

	}

	blk_account_io_merge(req);



	req->ioprio = ioprio_best(req->ioprio, next->ioprio);

	if (blk_rq_cpu_valid(next))

block/blk-sysfs.c

+4 −0
Original line number Diff line number Diff line
@@ -209,10 +209,14 @@ static ssize_t queue_iostats_store(struct request_queue *q, const char *page, 
	ssize_t ret = queue_var_store(&stats, page, count);



	spin_lock_irq(q->queue_lock);

	elv_quisce_start(q);



	if (stats)

		queue_flag_set(QUEUE_FLAG_IO_STAT, q);

	else

		queue_flag_clear(QUEUE_FLAG_IO_STAT, q);



	elv_quisce_end(q);

	spin_unlock_irq(q->queue_lock);



	return ret;