/* * PS3 FLASH ROM Storage Driver * * Copyright (C) 2007 Sony Computer Entertainment Inc. * Copyright 2007 Sony Corp. * * 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; version 2 of the License. * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include <linux/fs.h> #include <linux/miscdevice.h> #include <linux/uaccess.h> #include <asm/lv1call.h> #include <asm/ps3stor.h> #define DEVICE_NAME "ps3flash" #define FLASH_BLOCK_SIZE (256*1024) struct ps3flash_private { struct mutex mutex; /* Bounce buffer mutex */ }; 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) { u64 res = ps3stor_read_write_sectors(dev, lpar, start_sector, sectors, write); if (res) { dev_err(&dev->sbd.core, "%s:%u: %s failed 0x%lx\n", __func__, __LINE__, write ? "write" : "read", res); return -EIO; } return sectors; } static ssize_t ps3flash_read_sectors(struct ps3_storage_device *dev, u64 start_sector, u64 sectors, unsigned int sector_offset) { u64 max_sectors, lpar; max_sectors = dev->bounce_size / dev->blk_size; if (sectors > max_sectors) { dev_dbg(&dev->sbd.core, "%s:%u Limiting sectors to %lu\n", __func__, __LINE__, max_sectors); sectors = max_sectors; } lpar = dev->bounce_lpar + sector_offset * dev->blk_size; return ps3flash_read_write_sectors(dev, lpar, start_sector, sectors, 0); } static ssize_t ps3flash_write_chunk(struct ps3_storage_device *dev, u64 start_sector) { u64 sectors = dev->bounce_size / dev->blk_size; return ps3flash_read_write_sectors(dev, dev->bounce_lpar, start_sector, sectors, 1); } static loff_t ps3flash_llseek(struct file *file, loff_t offset, int origin) { struct ps3_storage_device *dev = ps3flash_dev; loff_t res; mutex_lock(&file->f_mapping->host->i_mutex); switch (origin) { case 1: offset += file->f_pos; break; case 2: offset += dev->regions[dev->region_idx].size*dev->blk_size; break; } if (offset < 0) { res = -EINVAL; goto out; } file->f_pos = offset; res = file->f_pos; out: mutex_unlock(&file->f_mapping->host->i_mutex); return res; } static ssize_t ps3flash_read(struct file *file, char __user *buf, size_t count, loff_t *pos) { struct ps3_storage_device *dev = ps3flash_dev; struct ps3flash_private *priv = dev->sbd.core.driver_data; u64 size, start_sector, end_sector, offset; ssize_t sectors_read; size_t remaining, n; dev_dbg(&dev->sbd.core, "%s:%u: Reading %zu bytes at position %lld to user 0x%p\n", __func__, __LINE__, count, *pos, buf); size = dev->regions[dev->region_idx].size*dev->blk_size; if (*pos >= size || !count) return 0; if (*pos + count > size) { dev_dbg(&dev->sbd.core, "%s:%u Truncating count from %zu to %llu\n", __func__, __LINE__, count, size - *pos); count = size - *pos; } start_sector = *pos / dev->blk_size; offset = *pos % dev->blk_size; end_sector = DIV_ROUND_UP(*pos + count, dev->blk_size); remaining = count; do { 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); goto fail; } n = min(remaining, sectors_read*dev->blk_size-offset); dev_dbg(&dev->sbd.core, "%s:%u: copy %lu bytes from 0x%p to user 0x%p\n", __func__, __LINE__, n, dev->bounce_buf+offset, buf); if (copy_to_user(buf, dev->bounce_buf+offset, n)) { mutex_unlock(&priv->mutex); sectors_read = -EFAULT; goto fail; } mutex_unlock(&priv->mutex); *pos += n; buf += n; remaining -= n; start_sector += sectors_read; offset = 0; } while (remaining > 0); return count; fail: return sectors_read; } static ssize_t ps3flash_write(struct file *file, const char __user *buf, size_t count, loff_t *pos) { struct ps3_storage_device *dev = ps3flash_dev; struct ps3flash_private *priv = dev->sbd.core.driver_data; u64 size, chunk_sectors, start_write_sector, end_write_sector, end_read_sector, start_read_sector, head, tail, offset; ssize_t res; size_t remaining, n; unsigned int sec_off; dev_dbg(&dev->sbd.core, "%s:%u: Writing %zu bytes at position %lld from user 0x%p\n", __func__, __LINE__, count, *pos, buf); size = dev->regions[dev->region_idx].size*dev->blk_size; if (*pos >= size || !count) return 0; if (*pos + count > size) { dev_dbg(&dev->sbd.core, "%s:%u Truncating count from %zu to %llu\n", __func__, __LINE__, count, size - *pos); count = size - *pos; } chunk_sectors = dev->bounce_size / dev->blk_size; start_write_sector = *pos / dev->bounce_size * 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 { mutex_lock(&priv->mutex); if (end_read_sector >= start_read_sector) { /* Merge head and tail */ dev_dbg(&dev->sbd.core, "Merged head and tail: %lu sectors at %lu\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: %lu sectors at %lu\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: %lu sectors at %lu\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; } } n = min(remaining, dev->bounce_size-offset); dev_dbg(&dev->sbd.core, "%s:%u: copy %lu bytes from user 0x%p to 0x%p\n", __func__, __LINE__, n, buf, dev->bounce_buf+offset); if (copy_from_user(dev->bounce_buf+offset, buf, n)) { res = -EFAULT; goto fail; } res = ps3flash_write_chunk(dev, start_write_sector); if (res < 0) goto fail; mutex_unlock(&priv->mutex); *pos += n; buf += n; remaining -= n; start_write_sector += chunk_sectors; head = 0; offset = 0; } while (remaining > 0); return count; fail: mutex_unlock(&priv->mutex); return res; } static irqreturn_t ps3flash_interrupt(int irq, void *data) { struct ps3_storage_device *dev = data; int res; u64 tag, status; res = lv1_storage_get_async_status(dev->sbd.dev_id, &tag, &status); if (tag != dev->tag) dev_err(&dev->sbd.core, "%s:%u: tag mismatch, got %lx, expected %lx\n", __func__, __LINE__, tag, dev->tag); if (res) { dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%lx\n", __func__, __LINE__, res, status); } else { dev->lv1_status = status; complete(&dev->done); } return IRQ_HANDLED; } static const struct file_operations ps3flash_fops = { .owner = THIS_MODULE, .llseek = ps3flash_llseek, .read = ps3flash_read, .write = ps3flash_write, }; static struct miscdevice ps3flash_misc = { .minor = MISC_DYNAMIC_MINOR, .name = DEVICE_NAME, .fops = &ps3flash_fops, }; static int __devinit ps3flash_probe(struct ps3_system_bus_device *_dev) { struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core); struct ps3flash_private *priv; int error; unsigned long tmp; tmp = dev->regions[dev->region_idx].start*dev->blk_size; if (tmp % FLASH_BLOCK_SIZE) { dev_err(&dev->sbd.core, "%s:%u region start %lu is not aligned\n", __func__, __LINE__, tmp); return -EINVAL; } tmp = dev->regions[dev->region_idx].size*dev->blk_size; if (tmp % FLASH_BLOCK_SIZE) { dev_err(&dev->sbd.core, "%s:%u region size %lu is not aligned\n", __func__, __LINE__, tmp); return -EINVAL; } /* use static buffer, kmalloc cannot allocate 256 KiB */ if (!ps3flash_bounce_buffer.address) return -ENODEV; if (ps3flash_dev) { dev_err(&dev->sbd.core, "Only one FLASH device is supported\n"); return -EBUSY; } ps3flash_dev = dev; priv = kzalloc(sizeof(*priv), GFP_KERNEL); if (!priv) { error = -ENOMEM; goto fail; } dev->sbd.core.driver_data = priv; mutex_init(&priv->mutex); dev->bounce_size = ps3flash_bounce_buffer.size; dev->bounce_buf = ps3flash_bounce_buffer.address; error = ps3stor_setup(dev, ps3flash_interrupt); if (error) goto fail_free_priv; ps3flash_misc.parent = &dev->sbd.core; error = misc_register(&ps3flash_misc); if (error) { dev_err(&dev->sbd.core, "%s:%u: misc_register failed %d\n", __func__, __LINE__, error); goto fail_teardown; } dev_info(&dev->sbd.core, "%s:%u: registered misc device %d\n", __func__, __LINE__, ps3flash_misc.minor); return 0; fail_teardown: ps3stor_teardown(dev); fail_free_priv: kfree(priv); dev->sbd.core.driver_data = NULL; fail: ps3flash_dev = NULL; return error; } static int ps3flash_remove(struct ps3_system_bus_device *_dev) { struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core); misc_deregister(&ps3flash_misc); ps3stor_teardown(dev); kfree(dev->sbd.core.driver_data); dev->sbd.core.driver_data = NULL; ps3flash_dev = NULL; return 0; } static struct ps3_system_bus_driver ps3flash = { .match_id = PS3_MATCH_ID_STOR_FLASH, .core.name = DEVICE_NAME, .core.owner = THIS_MODULE, .probe = ps3flash_probe, .remove = ps3flash_remove, .shutdown = ps3flash_remove, }; static int __init ps3flash_init(void) { return ps3_system_bus_driver_register(&ps3flash); } static void __exit ps3flash_exit(void) { ps3_system_bus_driver_unregister(&ps3flash); } module_init(ps3flash_init); module_exit(ps3flash_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("PS3 FLASH ROM Storage Driver"); MODULE_AUTHOR("Sony Corporation"); MODULE_ALIAS(PS3_MODULE_ALIAS_STOR_FLASH);