123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440 |
- /*
- * 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);
|