Skip to content

Commit

Permalink
---
Browse files Browse the repository at this point in the history 
yaml
---
r: 151084
b: refs/heads/master
c: 6bd57f2
h: refs/heads/master
v: v3
  • Loading branch information
Geert Uytterhoeven authored and Benjamin Herrenschmidt committed Jun 15, 2009
1 parent afcca94 commit 5605cc8
Show file tree
Hide file tree
Showing 2 changed files with 105 additions and 106 deletions.
2 changes: 1 addition & 1 deletion [refs]
View file
Original file line number Diff line number Diff line change
@@ -1,2 +1,2 @@
---
refs/heads/master: a4e623fbc9b201930abcf78df6db5e49aa8e00cb
refs/heads/master: 6bd57f2e5db408e0dfdb3bf052d58c4e7b18ed3c
209 changes: 104 additions & 105 deletions trunk/drivers/char/ps3flash.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -33,13 +33,16 @@

struct ps3flash_private {
struct mutex mutex; /* Bounce buffer mutex */
u64 chunk_sectors;
int tag; /* Start sector of buffer, -1 if invalid */
bool dirty;
};

static struct ps3_storage_device *ps3flash_dev;

static ssize_t ps3flash_read_write_sectors(struct ps3_storage_device *dev,
u64 lpar, u64 start_sector,
u64 sectors, int write)
static int ps3flash_read_write_sectors(struct ps3_storage_device *dev,
u64 lpar, u64 start_sector, u64 sectors,
int write)
{
u64 res = ps3stor_read_write_sectors(dev, lpar, start_sector, sectors,
write);
Expand All @@ -48,33 +51,55 @@ static ssize_t ps3flash_read_write_sectors(struct ps3_storage_device *dev,
__LINE__, write ? "write" : "read", res);
return -EIO;
}
return sectors;
return 0;
}

static ssize_t ps3flash_read_sectors(struct ps3_storage_device *dev,
u64 start_sector, u64 sectors,
unsigned int sector_offset)
static int ps3flash_writeback(struct ps3_storage_device *dev)
{
u64 max_sectors, lpar;
struct ps3flash_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
int res;

max_sectors = dev->bounce_size / dev->blk_size;
if (sectors > max_sectors) {
dev_dbg(&dev->sbd.core, "%s:%u Limiting sectors to %llu\n",
__func__, __LINE__, max_sectors);
sectors = max_sectors;
}
if (!priv->dirty || priv->tag < 0)
return 0;

res = ps3flash_read_write_sectors(dev, dev->bounce_lpar, priv->tag,
priv->chunk_sectors, 1);
if (res)
return res;

lpar = dev->bounce_lpar + sector_offset * dev->blk_size;
return ps3flash_read_write_sectors(dev, lpar, start_sector, sectors,
0);
priv->dirty = false;
return 0;
}

static ssize_t ps3flash_write_chunk(struct ps3_storage_device *dev,
u64 start_sector)
static int ps3flash_fetch(struct ps3_storage_device *dev, u64 start_sector,
u64 sectors)
{
u64 sectors = dev->bounce_size / dev->blk_size;
return ps3flash_read_write_sectors(dev, dev->bounce_lpar, start_sector,
sectors, 1);
struct ps3flash_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
unsigned int tag, offset;
u64 lpar;
int res;

offset = start_sector % priv->chunk_sectors;
tag = start_sector - offset;
if (tag == priv->tag)
return 0;

res = ps3flash_writeback(dev);
if (res)
return res;

priv->tag = -1;

lpar = dev->bounce_lpar + offset * dev->blk_size;
res = ps3flash_read_write_sectors(dev, lpar, start_sector, sectors, 0);
if (res)
return res;

/* We don't bother caching reads smaller than the chunk size */
if (sectors == priv->chunk_sectors)
priv->tag = tag;

return 0;
}

static loff_t ps3flash_llseek(struct file *file, loff_t offset, int origin)
Expand Down Expand Up @@ -109,8 +134,8 @@ static ssize_t ps3flash_read(char __user *userbuf, void *kernelbuf,
{
struct ps3_storage_device *dev = ps3flash_dev;
struct ps3flash_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
u64 size, start_sector, end_sector, offset;
ssize_t sectors_read;
u64 size, start_sector, end_sector, offset, sectors;
int res;
size_t remaining, n;
const void *src;

Expand All @@ -130,30 +155,29 @@ static ssize_t ps3flash_read(char __user *userbuf, void *kernelbuf,
}

start_sector = *pos / dev->blk_size;
offset = *pos % dev->blk_size;
offset = *pos % dev->bounce_size;
end_sector = DIV_ROUND_UP(*pos + count, dev->blk_size);

remaining = count;
do {
sectors = min(end_sector - start_sector,
priv->chunk_sectors -
start_sector % priv->chunk_sectors);

mutex_lock(&priv->mutex);

sectors_read = ps3flash_read_sectors(dev, start_sector,
end_sector-start_sector,
0);
if (sectors_read < 0) {
mutex_unlock(&priv->mutex);
res = ps3flash_fetch(dev, start_sector, sectors);
if (res)
goto fail;
}

n = min_t(u64, remaining, sectors_read*dev->blk_size-offset);
src = dev->bounce_buf+offset;
n = min_t(u64, remaining, dev->bounce_size - offset);
src = dev->bounce_buf + offset;
dev_dbg(&dev->sbd.core,
"%s:%u: copy %lu bytes from 0x%p to U0x%p/K0x%p\n",
__func__, __LINE__, n, src, userbuf, kernelbuf);
if (userbuf) {
if (copy_to_user(userbuf, src, n)) {
mutex_unlock(&priv->mutex);
sectors_read = -EFAULT;
res = -EFAULT;
goto fail;
}
userbuf += n;
Expand All @@ -167,26 +191,25 @@ static ssize_t ps3flash_read(char __user *userbuf, void *kernelbuf,

*pos += n;
remaining -= n;
start_sector += sectors_read;
start_sector += sectors;
offset = 0;
} while (remaining > 0);

return count;

fail:
return sectors_read;
mutex_unlock(&priv->mutex);
return res;
}

static ssize_t ps3flash_write(const char __user *userbuf,
const void *kernelbuf, size_t count, loff_t *pos)
{
struct ps3_storage_device *dev = ps3flash_dev;
struct ps3flash_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
u64 size, chunk_sectors, start_write_sector, end_write_sector,
end_read_sector, start_read_sector, head, tail, offset;
ssize_t res;
u64 size, sector, offset;
int res = 0;
size_t remaining, n;
unsigned int sec_off;
void *dst;

dev_dbg(&dev->sbd.core,
Expand All @@ -204,71 +227,23 @@ static ssize_t ps3flash_write(const char __user *userbuf,
count = size - *pos;
}

chunk_sectors = dev->bounce_size / dev->blk_size;

start_write_sector = *pos / dev->bounce_size * chunk_sectors;
sector = *pos / dev->bounce_size * priv->chunk_sectors;
offset = *pos % dev->bounce_size;
end_write_sector = DIV_ROUND_UP(*pos + count, dev->bounce_size) *
chunk_sectors;

end_read_sector = DIV_ROUND_UP(*pos, dev->blk_size);
start_read_sector = (*pos + count) / dev->blk_size;

/*
* As we have to write in 256 KiB chunks, while we can read in blk_size
* (usually 512 bytes) chunks, we perform the following steps:
* 1. Read from start_write_sector to end_read_sector ("head")
* 2. Read from start_read_sector to end_write_sector ("tail")
* 3. Copy data to buffer
* 4. Write from start_write_sector to end_write_sector
* All of this is complicated by using only one 256 KiB bounce buffer.
*/

head = end_read_sector - start_write_sector;
tail = end_write_sector - start_read_sector;

remaining = count;
do {
n = min_t(u64, remaining, dev->bounce_size - offset);

mutex_lock(&priv->mutex);

if (end_read_sector >= start_read_sector) {
/* Merge head and tail */
dev_dbg(&dev->sbd.core,
"Merged head and tail: %llu sectors at %llu\n",
chunk_sectors, start_write_sector);
res = ps3flash_read_sectors(dev, start_write_sector,
chunk_sectors, 0);
if (res < 0)
goto fail;
} else {
if (head) {
/* Read head */
dev_dbg(&dev->sbd.core,
"head: %llu sectors at %llu\n", head,
start_write_sector);
res = ps3flash_read_sectors(dev,
start_write_sector,
head, 0);
if (res < 0)
goto fail;
}
if (start_read_sector <
start_write_sector+chunk_sectors) {
/* Read tail */
dev_dbg(&dev->sbd.core,
"tail: %llu sectors at %llu\n", tail,
start_read_sector);
sec_off = start_read_sector-start_write_sector;
res = ps3flash_read_sectors(dev,
start_read_sector,
tail, sec_off);
if (res < 0)
goto fail;
}
}
if (n != dev->bounce_size)
res = ps3flash_fetch(dev, sector, priv->chunk_sectors);
else if (sector != priv->tag)
res = ps3flash_writeback(dev);
if (res)
goto fail;

n = min_t(u64, remaining, dev->bounce_size-offset);
dst = dev->bounce_buf+offset;
dst = dev->bounce_buf + offset;
dev_dbg(&dev->sbd.core,
"%s:%u: copy %lu bytes from U0x%p/K0x%p to 0x%p\n",
__func__, __LINE__, n, userbuf, kernelbuf, dst);
Expand All @@ -284,16 +259,14 @@ static ssize_t ps3flash_write(const char __user *userbuf,
kernelbuf += n;
}

res = ps3flash_write_chunk(dev, start_write_sector);
if (res < 0)
goto fail;
priv->tag = sector;
priv->dirty = true;

mutex_unlock(&priv->mutex);

*pos += n;
remaining -= n;
start_write_sector += chunk_sectors;
head = 0;
sector += priv->chunk_sectors;
offset = 0;
} while (remaining > 0);

Expand Down Expand Up @@ -324,9 +297,31 @@ static ssize_t ps3flash_kernel_read(void *buf, size_t count, loff_t pos)
static ssize_t ps3flash_kernel_write(const void *buf, size_t count,
loff_t pos)
{
return ps3flash_write(NULL, buf, count, &pos);
ssize_t res;
int wb;

res = ps3flash_write(NULL, buf, count, &pos);
if (res < 0)
return res;

/* Make kernel writes synchronous */
wb = ps3flash_writeback(ps3flash_dev);
if (wb)
return wb;

return res;
}

static int ps3flash_flush(struct file *file, fl_owner_t id)
{
return ps3flash_writeback(ps3flash_dev);
}

static int ps3flash_fsync(struct file *file, struct dentry *dentry,
int datasync)
{
return ps3flash_writeback(ps3flash_dev);
}

static irqreturn_t ps3flash_interrupt(int irq, void *data)
{
Expand Down Expand Up @@ -356,6 +351,8 @@ static const struct file_operations ps3flash_fops = {
.llseek = ps3flash_llseek,
.read = ps3flash_user_read,
.write = ps3flash_user_write,
.flush = ps3flash_flush,
.fsync = ps3flash_fsync,
};

static const struct ps3_os_area_flash_ops ps3flash_kernel_ops = {
Expand Down Expand Up @@ -411,9 +408,11 @@ static int __devinit ps3flash_probe(struct ps3_system_bus_device *_dev)

ps3_system_bus_set_drvdata(&dev->sbd, priv);
mutex_init(&priv->mutex);
priv->tag = -1;

dev->bounce_size = ps3flash_bounce_buffer.size;
dev->bounce_buf = ps3flash_bounce_buffer.address;
priv->chunk_sectors = dev->bounce_size / dev->blk_size;

error = ps3stor_setup(dev, ps3flash_interrupt);
if (error)
Expand Down

0 comments on commit 5605cc8

Please sign in to comment.