linux-imx
Public
Source
committed fab1adcf950 * 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/ata.h>#include <linux/blkdev.h>#include <linux/blk-mq.h>#include <linux/slab.h>#include <linux/module.h>#include <asm/lv1call.h>#include <asm/ps3stor.h>#include <asm/firmware.h>#define DEVICE_NAME "ps3disk"#define PS3DISK_MAX_DISKS 16#define PS3DISK_MINORS 16#define PS3DISK_NAME "ps3d%c"struct ps3disk_private { spinlock_t lock; /* Request queue spinlock */ struct request_queue *queue; struct blk_mq_tag_set tag_set; struct gendisk *gendisk; unsigned int blocking_factor; struct request *req; u64 raw_capacity; unsigned char model[ATA_ID_PROD_LEN+1];};#define LV1_STORAGE_SEND_ATA_COMMAND (2)#define LV1_STORAGE_ATA_HDDOUT (0x23) memcpy(dev->bounce_buf+offset, buf, size); else memcpy(buf, dev->bounce_buf+offset, size); offset += size; flush_kernel_dcache_page(bvec.bv_page); bvec_kunmap_irq(buf, &flags); i++; }}static int ps3disk_submit_request_sg(struct ps3_storage_device *dev, struct request *req)static blk_status_t ps3disk_submit_request_sg(struct ps3_storage_device *dev, struct request *req){ struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd); int write = rq_data_dir(req), res; const char *op = write ? "write" : "read"; u64 start_sector, sectors; unsigned int region_id = dev->regions[dev->region_idx].id;#ifdef DEBUG unsigned int n = 0; struct bio_vec bv; start_sector, sectors, 0, dev->bounce_lpar, &dev->tag); } else { res = lv1_storage_read(dev->sbd.dev_id, region_id, start_sector, sectors, 0, dev->bounce_lpar, &dev->tag); } if (res) { dev_err(&dev->sbd.core, "%s:%u: %s failed %d\n", __func__, __LINE__, op, res); __blk_end_request_all(req, BLK_STS_IOERR); return 0; return BLK_STS_IOERR; } priv->req = req; return 1; return BLK_STS_OK;}static int ps3disk_submit_flush_request(struct ps3_storage_device *dev, struct request *req)static blk_status_t ps3disk_submit_flush_request(struct ps3_storage_device *dev, struct request *req){ struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd); u64 res; dev_dbg(&dev->sbd.core, "%s:%u: flush request\n", __func__, __LINE__); res = lv1_storage_send_device_command(dev->sbd.dev_id, LV1_STORAGE_ATA_HDDOUT, 0, 0, 0, 0, &dev->tag); if (res) { dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%llx\n", __func__, __LINE__, res); __blk_end_request_all(req, BLK_STS_IOERR); return 0; return BLK_STS_IOERR; } priv->req = req; return 1; return BLK_STS_OK;}static void ps3disk_do_request(struct ps3_storage_device *dev, struct request_queue *q)static blk_status_t ps3disk_do_request(struct ps3_storage_device *dev, struct request *req){ struct request *req; dev_dbg(&dev->sbd.core, "%s:%u\n", __func__, __LINE__); while ((req = blk_fetch_request(q))) { switch (req_op(req)) { case REQ_OP_FLUSH: if (ps3disk_submit_flush_request(dev, req)) return; break; case REQ_OP_READ: case REQ_OP_WRITE: if (ps3disk_submit_request_sg(dev, req)) return; break; default: blk_dump_rq_flags(req, DEVICE_NAME " bad request"); __blk_end_request_all(req, BLK_STS_IOERR); } switch (req_op(req)) { case REQ_OP_FLUSH: return ps3disk_submit_flush_request(dev, req); case REQ_OP_READ: case REQ_OP_WRITE: return ps3disk_submit_request_sg(dev, req); default: blk_dump_rq_flags(req, DEVICE_NAME " bad request"); return BLK_STS_IOERR; }}static void ps3disk_request(struct request_queue *q)static blk_status_t ps3disk_queue_rq(struct blk_mq_hw_ctx *hctx, const struct blk_mq_queue_data *bd){ struct request_queue *q = hctx->queue; struct ps3_storage_device *dev = q->queuedata; struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd); blk_status_t ret; if (priv->req) { dev_dbg(&dev->sbd.core, "%s:%u busy\n", __func__, __LINE__); return; } blk_mq_start_request(bd->rq); spin_lock_irq(&priv->lock); ret = ps3disk_do_request(dev, bd->rq); spin_unlock_irq(&priv->lock); ps3disk_do_request(dev, q); return ret;}static irqreturn_t ps3disk_interrupt(int irq, void *data){ struct ps3_storage_device *dev = data; struct ps3disk_private *priv; struct request *req; int res, read; blk_status_t error; u64 tag, status; error = BLK_STS_IOERR; } else { dev_dbg(&dev->sbd.core, "%s:%u: %s completed\n", __func__, __LINE__, op); error = 0; if (read) ps3disk_scatter_gather(dev, req, 0); } spin_lock(&priv->lock); __blk_end_request_all(req, error); priv->req = NULL; ps3disk_do_request(dev, priv->queue); blk_mq_end_request(req, error); spin_unlock(&priv->lock); blk_mq_run_hw_queues(priv->queue, true); return IRQ_HANDLED;}static int ps3disk_sync_cache(struct ps3_storage_device *dev){ u64 res; dev_dbg(&dev->sbd.core, "%s:%u: sync cache\n", __func__, __LINE__); res = ps3stor_send_command(dev, LV1_STORAGE_ATA_HDDOUT, 0, 0, 0, 0); /* All we're interested in are raw capacity and model name */ priv->raw_capacity = ata_id_n_sectors(id); ata_id_c_string(id, priv->model, ATA_ID_PROD, sizeof(priv->model)); return 0;}static unsigned long ps3disk_mask;static DEFINE_MUTEX(ps3disk_mask_mutex);static const struct blk_mq_ops ps3disk_mq_ops = { .queue_rq = ps3disk_queue_rq,};static int ps3disk_probe(struct ps3_system_bus_device *_dev){ struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core); struct ps3disk_private *priv; int error; unsigned int devidx; struct request_queue *queue; struct gendisk *gendisk; if (dev->blk_size < 512) { error = -ENOMEM; goto fail_free_priv; } error = ps3stor_setup(dev, ps3disk_interrupt); if (error) goto fail_free_bounce; ps3disk_identify(dev); queue = blk_init_queue(ps3disk_request, &priv->lock); if (!queue) { dev_err(&dev->sbd.core, "%s:%u: blk_init_queue failed\n", queue = blk_mq_init_sq_queue(&priv->tag_set, &ps3disk_mq_ops, 1, BLK_MQ_F_SHOULD_MERGE); if (IS_ERR(queue)) { dev_err(&dev->sbd.core, "%s:%u: blk_mq_init_queue failed\n", __func__, __LINE__); error = -ENOMEM; error = PTR_ERR(queue); goto fail_teardown; } priv->queue = queue; queue->queuedata = dev; blk_queue_max_hw_sectors(queue, dev->bounce_size >> 9); blk_queue_segment_boundary(queue, -1UL); blk_queue_dma_alignment(queue, dev->blk_size-1); blk_queue_logical_block_size(queue, dev->blk_size); dev_info(&dev->sbd.core, "%s is a %s (%llu MiB total, %lu MiB for OtherOS)\n", gendisk->disk_name, priv->model, priv->raw_capacity >> 11, get_capacity(gendisk) >> 11); device_add_disk(&dev->sbd.core, gendisk, NULL); return 0;fail_cleanup_queue: blk_cleanup_queue(queue); blk_mq_free_tag_set(&priv->tag_set);fail_teardown: ps3stor_teardown(dev);fail_free_bounce: kfree(dev->bounce_buf);fail_free_priv: kfree(priv); ps3_system_bus_set_drvdata(_dev, NULL);fail: mutex_lock(&ps3disk_mask_mutex); __clear_bit(devidx, &ps3disk_mask);{ struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core); struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd); mutex_lock(&ps3disk_mask_mutex); __clear_bit(MINOR(disk_devt(priv->gendisk)) / PS3DISK_MINORS, &ps3disk_mask); mutex_unlock(&ps3disk_mask_mutex); del_gendisk(priv->gendisk); blk_cleanup_queue(priv->queue); blk_mq_free_tag_set(&priv->tag_set); put_disk(priv->gendisk); dev_notice(&dev->sbd.core, "Synchronizing disk cache\n"); ps3disk_sync_cache(dev); ps3stor_teardown(dev); kfree(dev->bounce_buf); kfree(priv); ps3_system_bus_set_drvdata(_dev, NULL); return 0;}