adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-27 19:26:25 +00:00
Code Issues Projects Releases Packages Wiki Activity

ps3flash: Always read chunks of 256 KiB, and cache them

Browse source 
Signed-off-by: Geert Uytterhoeven <Geert.Uytterhoeven@sonycom.com>
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
This commit is contained in:
Geert Uytterhoeven 2009-06-10 04:39:08 +00:00 committed by Benjamin Herrenschmidt
parent 6bd57f2e5d
commit 42e27bfc4b
1 changed files with 17 additions and 30 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

47
drivers/char/ps3flash.c
View file

@ -41,10 +41,11 @@ struct ps3flash_private {
static struct ps3_storage_device *ps3flash_dev; static struct ps3_storage_device *ps3flash_dev;
static int ps3flash_read_write_sectors(struct ps3_storage_device *dev, static int ps3flash_read_write_sectors(struct ps3_storage_device *dev,
u64 lpar, u64 start_sector, u64 sectors, u64 start_sector, int write)
int write)
{ {
u64 res = ps3stor_read_write_sectors(dev, lpar, start_sector, sectors, struct ps3flash_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
u64 res = ps3stor_read_write_sectors(dev, dev->bounce_lpar,
start_sector, priv->chunk_sectors,
write); write);
if (res) { if (res) {
dev_err(&dev->sbd.core, "%s:%u: %s failed 0x%llx\n", __func__, dev_err(&dev->sbd.core, "%s:%u: %s failed 0x%llx\n", __func__,
@ -62,8 +63,7 @@ static int ps3flash_writeback(struct ps3_storage_device *dev)
if (!priv->dirty || priv->tag < 0) if (!priv->dirty || priv->tag < 0)
return 0; return 0;
res = ps3flash_read_write_sectors(dev, dev->bounce_lpar, priv->tag, res = ps3flash_read_write_sectors(dev, priv->tag, 1);
priv->chunk_sectors, 1);
if (res) if (res)
return res; return res;
@ -71,17 +71,12 @@ static int ps3flash_writeback(struct ps3_storage_device *dev)
return 0; return 0;
} }
static int ps3flash_fetch(struct ps3_storage_device *dev, u64 start_sector, static int ps3flash_fetch(struct ps3_storage_device *dev, u64 start_sector)
u64 sectors)
{ {
struct ps3flash_private *priv = ps3_system_bus_get_drvdata(&dev->sbd); struct ps3flash_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
unsigned int tag, offset;
u64 lpar;
int res; int res;
offset = start_sector % priv->chunk_sectors; if (start_sector == priv->tag)
tag = start_sector - offset;
if (tag == priv->tag)
return 0; return 0;
res = ps3flash_writeback(dev); res = ps3flash_writeback(dev);
@ -90,15 +85,11 @@ static int ps3flash_fetch(struct ps3_storage_device *dev, u64 start_sector,
priv->tag = -1; priv->tag = -1;
lpar = dev->bounce_lpar + offset * dev->blk_size; res = ps3flash_read_write_sectors(dev, start_sector, 0);
res = ps3flash_read_write_sectors(dev, lpar, start_sector, sectors, 0);
if (res) if (res)
return res; return res;
/* We don't bother caching reads smaller than the chunk size */ priv->tag = start_sector;
if (sectors == priv->chunk_sectors)
priv->tag = tag;
return 0; return 0;
} }
@ -134,7 +125,7 @@ static ssize_t ps3flash_read(char __user *userbuf, void *kernelbuf,
{ {
struct ps3_storage_device *dev = ps3flash_dev; struct ps3_storage_device *dev = ps3flash_dev;
struct ps3flash_private *priv = ps3_system_bus_get_drvdata(&dev->sbd); struct ps3flash_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
u64 size, start_sector, end_sector, offset, sectors; u64 size, sector, offset;
int res; int res;
size_t remaining, n; size_t remaining, n;
const void *src; const void *src;
@ -154,24 +145,20 @@ static ssize_t ps3flash_read(char __user *userbuf, void *kernelbuf,
count = size - *pos; count = size - *pos;
} }
start_sector = *pos / dev->blk_size; sector = *pos / dev->bounce_size * priv->chunk_sectors;
offset = *pos % dev->bounce_size; offset = *pos % dev->bounce_size;
end_sector = DIV_ROUND_UP(*pos + count, dev->blk_size);
remaining = count; remaining = count;
do { do {
sectors = min(end_sector - start_sector, n = min_t(u64, remaining, dev->bounce_size - offset);
priv->chunk_sectors - src = dev->bounce_buf + offset;
start_sector % priv->chunk_sectors);
mutex_lock(&priv->mutex); mutex_lock(&priv->mutex);
res = ps3flash_fetch(dev, start_sector, sectors); res = ps3flash_fetch(dev, sector);
if (res) if (res)
goto fail; goto fail;
n = min_t(u64, remaining, dev->bounce_size - offset);
src = dev->bounce_buf + offset;
dev_dbg(&dev->sbd.core, dev_dbg(&dev->sbd.core,
"%s:%u: copy %lu bytes from 0x%p to U0x%p/K0x%p\n", "%s:%u: copy %lu bytes from 0x%p to U0x%p/K0x%p\n",
__func__, __LINE__, n, src, userbuf, kernelbuf); __func__, __LINE__, n, src, userbuf, kernelbuf);
@ -191,7 +178,7 @@ static ssize_t ps3flash_read(char __user *userbuf, void *kernelbuf,
*pos += n; *pos += n;
remaining -= n; remaining -= n;
start_sector += sectors; sector += priv->chunk_sectors;
offset = 0; offset = 0;
} while (remaining > 0); } while (remaining > 0);
@ -233,17 +220,17 @@ static ssize_t ps3flash_write(const char __user *userbuf,
remaining = count; remaining = count;
do { do {
n = min_t(u64, remaining, dev->bounce_size - offset); n = min_t(u64, remaining, dev->bounce_size - offset);
dst = dev->bounce_buf + offset;
mutex_lock(&priv->mutex); mutex_lock(&priv->mutex);
if (n != dev->bounce_size) if (n != dev->bounce_size)
res = ps3flash_fetch(dev, sector, priv->chunk_sectors); res = ps3flash_fetch(dev, sector);
else if (sector != priv->tag) else if (sector != priv->tag)
res = ps3flash_writeback(dev); res = ps3flash_writeback(dev);
if (res) if (res)
goto fail; goto fail;
dst = dev->bounce_buf + offset;
dev_dbg(&dev->sbd.core, dev_dbg(&dev->sbd.core,
"%s:%u: copy %lu bytes from U0x%p/K0x%p to 0x%p\n", "%s:%u: copy %lu bytes from U0x%p/K0x%p to 0x%p\n",
__func__, __LINE__, n, userbuf, kernelbuf, dst); __func__, __LINE__, n, userbuf, kernelbuf, dst);