Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * PS3 Disk Storage Driver
0004  *
0005  * Copyright (C) 2007 Sony Computer Entertainment Inc.
0006  * Copyright 2007 Sony Corp.
0007  */
0008 
0009 #include <linux/ata.h>
0010 #include <linux/blk-mq.h>
0011 #include <linux/slab.h>
0012 #include <linux/module.h>
0013 
0014 #include <asm/lv1call.h>
0015 #include <asm/ps3stor.h>
0016 #include <asm/firmware.h>
0017 
0018 
0019 #define DEVICE_NAME     "ps3disk"
0020 
0021 #define BOUNCE_SIZE     (64*1024)
0022 
0023 #define PS3DISK_MAX_DISKS   16
0024 #define PS3DISK_MINORS      16
0025 
0026 
0027 #define PS3DISK_NAME        "ps3d%c"
0028 
0029 
0030 struct ps3disk_private {
0031     spinlock_t lock;        /* Request queue spinlock */
0032     struct blk_mq_tag_set tag_set;
0033     struct gendisk *gendisk;
0034     unsigned int blocking_factor;
0035     struct request *req;
0036     u64 raw_capacity;
0037     unsigned char model[ATA_ID_PROD_LEN+1];
0038 };
0039 
0040 
0041 #define LV1_STORAGE_SEND_ATA_COMMAND    (2)
0042 #define LV1_STORAGE_ATA_HDDOUT      (0x23)
0043 
0044 struct lv1_ata_cmnd_block {
0045     u16 features;
0046     u16 sector_count;
0047     u16 LBA_low;
0048     u16 LBA_mid;
0049     u16 LBA_high;
0050     u8  device;
0051     u8  command;
0052     u32 is_ext;
0053     u32 proto;
0054     u32 in_out;
0055     u32 size;
0056     u64 buffer;
0057     u32 arglen;
0058 };
0059 
0060 enum lv1_ata_proto {
0061     NON_DATA_PROTO     = 0,
0062     PIO_DATA_IN_PROTO  = 1,
0063     PIO_DATA_OUT_PROTO = 2,
0064     DMA_PROTO = 3
0065 };
0066 
0067 enum lv1_ata_in_out {
0068     DIR_WRITE = 0,          /* memory -> device */
0069     DIR_READ = 1            /* device -> memory */
0070 };
0071 
0072 static int ps3disk_major;
0073 
0074 
0075 static const struct block_device_operations ps3disk_fops = {
0076     .owner      = THIS_MODULE,
0077 };
0078 
0079 
0080 static void ps3disk_scatter_gather(struct ps3_storage_device *dev,
0081                    struct request *req, int gather)
0082 {
0083     unsigned int offset = 0;
0084     struct req_iterator iter;
0085     struct bio_vec bvec;
0086 
0087     rq_for_each_segment(bvec, req, iter) {
0088         if (gather)
0089             memcpy_from_bvec(dev->bounce_buf + offset, &bvec);
0090         else
0091             memcpy_to_bvec(&bvec, dev->bounce_buf + offset);
0092     }
0093 }
0094 
0095 static blk_status_t ps3disk_submit_request_sg(struct ps3_storage_device *dev,
0096                           struct request *req)
0097 {
0098     struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
0099     int write = rq_data_dir(req), res;
0100     const char *op = write ? "write" : "read";
0101     u64 start_sector, sectors;
0102     unsigned int region_id = dev->regions[dev->region_idx].id;
0103 
0104 #ifdef DEBUG
0105     unsigned int n = 0;
0106     struct bio_vec bv;
0107     struct req_iterator iter;
0108 
0109     rq_for_each_segment(bv, req, iter)
0110         n++;
0111     dev_dbg(&dev->sbd.core,
0112         "%s:%u: %s req has %u bvecs for %u sectors\n",
0113         __func__, __LINE__, op, n, blk_rq_sectors(req));
0114 #endif
0115 
0116     start_sector = blk_rq_pos(req) * priv->blocking_factor;
0117     sectors = blk_rq_sectors(req) * priv->blocking_factor;
0118     dev_dbg(&dev->sbd.core, "%s:%u: %s %llu sectors starting at %llu\n",
0119         __func__, __LINE__, op, sectors, start_sector);
0120 
0121     if (write) {
0122         ps3disk_scatter_gather(dev, req, 1);
0123 
0124         res = lv1_storage_write(dev->sbd.dev_id, region_id,
0125                     start_sector, sectors, 0,
0126                     dev->bounce_lpar, &dev->tag);
0127     } else {
0128         res = lv1_storage_read(dev->sbd.dev_id, region_id,
0129                        start_sector, sectors, 0,
0130                        dev->bounce_lpar, &dev->tag);
0131     }
0132     if (res) {
0133         dev_err(&dev->sbd.core, "%s:%u: %s failed %d\n", __func__,
0134             __LINE__, op, res);
0135         return BLK_STS_IOERR;
0136     }
0137 
0138     priv->req = req;
0139     return BLK_STS_OK;
0140 }
0141 
0142 static blk_status_t ps3disk_submit_flush_request(struct ps3_storage_device *dev,
0143                          struct request *req)
0144 {
0145     struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
0146     u64 res;
0147 
0148     dev_dbg(&dev->sbd.core, "%s:%u: flush request\n", __func__, __LINE__);
0149 
0150     res = lv1_storage_send_device_command(dev->sbd.dev_id,
0151                           LV1_STORAGE_ATA_HDDOUT, 0, 0, 0,
0152                           0, &dev->tag);
0153     if (res) {
0154         dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%llx\n",
0155             __func__, __LINE__, res);
0156         return BLK_STS_IOERR;
0157     }
0158 
0159     priv->req = req;
0160     return BLK_STS_OK;
0161 }
0162 
0163 static blk_status_t ps3disk_do_request(struct ps3_storage_device *dev,
0164                        struct request *req)
0165 {
0166     dev_dbg(&dev->sbd.core, "%s:%u\n", __func__, __LINE__);
0167 
0168     switch (req_op(req)) {
0169     case REQ_OP_FLUSH:
0170         return ps3disk_submit_flush_request(dev, req);
0171     case REQ_OP_READ:
0172     case REQ_OP_WRITE:
0173         return ps3disk_submit_request_sg(dev, req);
0174     default:
0175         blk_dump_rq_flags(req, DEVICE_NAME " bad request");
0176         return BLK_STS_IOERR;
0177     }
0178 }
0179 
0180 static blk_status_t ps3disk_queue_rq(struct blk_mq_hw_ctx *hctx,
0181                      const struct blk_mq_queue_data *bd)
0182 {
0183     struct request_queue *q = hctx->queue;
0184     struct ps3_storage_device *dev = q->queuedata;
0185     struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
0186     blk_status_t ret;
0187 
0188     blk_mq_start_request(bd->rq);
0189 
0190     spin_lock_irq(&priv->lock);
0191     ret = ps3disk_do_request(dev, bd->rq);
0192     spin_unlock_irq(&priv->lock);
0193 
0194     return ret;
0195 }
0196 
0197 static irqreturn_t ps3disk_interrupt(int irq, void *data)
0198 {
0199     struct ps3_storage_device *dev = data;
0200     struct ps3disk_private *priv;
0201     struct request *req;
0202     int res, read;
0203     blk_status_t error;
0204     u64 tag, status;
0205     const char *op;
0206 
0207     res = lv1_storage_get_async_status(dev->sbd.dev_id, &tag, &status);
0208 
0209     if (tag != dev->tag)
0210         dev_err(&dev->sbd.core,
0211             "%s:%u: tag mismatch, got %llx, expected %llx\n",
0212             __func__, __LINE__, tag, dev->tag);
0213 
0214     if (res) {
0215         dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%llx\n",
0216             __func__, __LINE__, res, status);
0217         return IRQ_HANDLED;
0218     }
0219 
0220     priv = ps3_system_bus_get_drvdata(&dev->sbd);
0221     req = priv->req;
0222     if (!req) {
0223         dev_dbg(&dev->sbd.core,
0224             "%s:%u non-block layer request completed\n", __func__,
0225             __LINE__);
0226         dev->lv1_status = status;
0227         complete(&dev->done);
0228         return IRQ_HANDLED;
0229     }
0230 
0231     if (req_op(req) == REQ_OP_FLUSH) {
0232         read = 0;
0233         op = "flush";
0234     } else {
0235         read = !rq_data_dir(req);
0236         op = read ? "read" : "write";
0237     }
0238     if (status) {
0239         dev_dbg(&dev->sbd.core, "%s:%u: %s failed 0x%llx\n", __func__,
0240             __LINE__, op, status);
0241         error = BLK_STS_IOERR;
0242     } else {
0243         dev_dbg(&dev->sbd.core, "%s:%u: %s completed\n", __func__,
0244             __LINE__, op);
0245         error = 0;
0246         if (read)
0247             ps3disk_scatter_gather(dev, req, 0);
0248     }
0249 
0250     spin_lock(&priv->lock);
0251     priv->req = NULL;
0252     blk_mq_end_request(req, error);
0253     spin_unlock(&priv->lock);
0254 
0255     blk_mq_run_hw_queues(priv->gendisk->queue, true);
0256     return IRQ_HANDLED;
0257 }
0258 
0259 static int ps3disk_sync_cache(struct ps3_storage_device *dev)
0260 {
0261     u64 res;
0262 
0263     dev_dbg(&dev->sbd.core, "%s:%u: sync cache\n", __func__, __LINE__);
0264 
0265     res = ps3stor_send_command(dev, LV1_STORAGE_ATA_HDDOUT, 0, 0, 0, 0);
0266     if (res) {
0267         dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%llx\n",
0268             __func__, __LINE__, res);
0269         return -EIO;
0270     }
0271     return 0;
0272 }
0273 
0274 
0275 /* ATA helpers copied from drivers/ata/libata-core.c */
0276 
0277 static void swap_buf_le16(u16 *buf, unsigned int buf_words)
0278 {
0279 #ifdef __BIG_ENDIAN
0280     unsigned int i;
0281 
0282     for (i = 0; i < buf_words; i++)
0283         buf[i] = le16_to_cpu(buf[i]);
0284 #endif /* __BIG_ENDIAN */
0285 }
0286 
0287 static u64 ata_id_n_sectors(const u16 *id)
0288 {
0289     if (ata_id_has_lba(id)) {
0290         if (ata_id_has_lba48(id))
0291             return ata_id_u64(id, 100);
0292         else
0293             return ata_id_u32(id, 60);
0294     } else {
0295         if (ata_id_current_chs_valid(id))
0296             return ata_id_u32(id, 57);
0297         else
0298             return id[1] * id[3] * id[6];
0299     }
0300 }
0301 
0302 static void ata_id_string(const u16 *id, unsigned char *s, unsigned int ofs,
0303               unsigned int len)
0304 {
0305     unsigned int c;
0306 
0307     while (len > 0) {
0308         c = id[ofs] >> 8;
0309         *s = c;
0310         s++;
0311 
0312         c = id[ofs] & 0xff;
0313         *s = c;
0314         s++;
0315 
0316         ofs++;
0317         len -= 2;
0318     }
0319 }
0320 
0321 static void ata_id_c_string(const u16 *id, unsigned char *s, unsigned int ofs,
0322                 unsigned int len)
0323 {
0324     unsigned char *p;
0325 
0326     WARN_ON(!(len & 1));
0327 
0328     ata_id_string(id, s, ofs, len - 1);
0329 
0330     p = s + strnlen(s, len - 1);
0331     while (p > s && p[-1] == ' ')
0332         p--;
0333     *p = '\0';
0334 }
0335 
0336 static int ps3disk_identify(struct ps3_storage_device *dev)
0337 {
0338     struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
0339     struct lv1_ata_cmnd_block ata_cmnd;
0340     u16 *id = dev->bounce_buf;
0341     u64 res;
0342 
0343     dev_dbg(&dev->sbd.core, "%s:%u: identify disk\n", __func__, __LINE__);
0344 
0345     memset(&ata_cmnd, 0, sizeof(struct lv1_ata_cmnd_block));
0346     ata_cmnd.command = ATA_CMD_ID_ATA;
0347     ata_cmnd.sector_count = 1;
0348     ata_cmnd.size = ata_cmnd.arglen = ATA_ID_WORDS * 2;
0349     ata_cmnd.buffer = dev->bounce_lpar;
0350     ata_cmnd.proto = PIO_DATA_IN_PROTO;
0351     ata_cmnd.in_out = DIR_READ;
0352 
0353     res = ps3stor_send_command(dev, LV1_STORAGE_SEND_ATA_COMMAND,
0354                    ps3_mm_phys_to_lpar(__pa(&ata_cmnd)),
0355                    sizeof(ata_cmnd), ata_cmnd.buffer,
0356                    ata_cmnd.arglen);
0357     if (res) {
0358         dev_err(&dev->sbd.core, "%s:%u: identify disk failed 0x%llx\n",
0359             __func__, __LINE__, res);
0360         return -EIO;
0361     }
0362 
0363     swap_buf_le16(id, ATA_ID_WORDS);
0364 
0365     /* All we're interested in are raw capacity and model name */
0366     priv->raw_capacity = ata_id_n_sectors(id);
0367     ata_id_c_string(id, priv->model, ATA_ID_PROD, sizeof(priv->model));
0368     return 0;
0369 }
0370 
0371 static unsigned long ps3disk_mask;
0372 
0373 static DEFINE_MUTEX(ps3disk_mask_mutex);
0374 
0375 static const struct blk_mq_ops ps3disk_mq_ops = {
0376     .queue_rq   = ps3disk_queue_rq,
0377 };
0378 
0379 static int ps3disk_probe(struct ps3_system_bus_device *_dev)
0380 {
0381     struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
0382     struct ps3disk_private *priv;
0383     int error;
0384     unsigned int devidx;
0385     struct request_queue *queue;
0386     struct gendisk *gendisk;
0387 
0388     if (dev->blk_size < 512) {
0389         dev_err(&dev->sbd.core,
0390             "%s:%u: cannot handle block size %llu\n", __func__,
0391             __LINE__, dev->blk_size);
0392         return -EINVAL;
0393     }
0394 
0395     BUILD_BUG_ON(PS3DISK_MAX_DISKS > BITS_PER_LONG);
0396     mutex_lock(&ps3disk_mask_mutex);
0397     devidx = find_first_zero_bit(&ps3disk_mask, PS3DISK_MAX_DISKS);
0398     if (devidx >= PS3DISK_MAX_DISKS) {
0399         dev_err(&dev->sbd.core, "%s:%u: Too many disks\n", __func__,
0400             __LINE__);
0401         mutex_unlock(&ps3disk_mask_mutex);
0402         return -ENOSPC;
0403     }
0404     __set_bit(devidx, &ps3disk_mask);
0405     mutex_unlock(&ps3disk_mask_mutex);
0406 
0407     priv = kzalloc(sizeof(*priv), GFP_KERNEL);
0408     if (!priv) {
0409         error = -ENOMEM;
0410         goto fail;
0411     }
0412 
0413     ps3_system_bus_set_drvdata(_dev, priv);
0414     spin_lock_init(&priv->lock);
0415 
0416     dev->bounce_size = BOUNCE_SIZE;
0417     dev->bounce_buf = kmalloc(BOUNCE_SIZE, GFP_DMA);
0418     if (!dev->bounce_buf) {
0419         error = -ENOMEM;
0420         goto fail_free_priv;
0421     }
0422 
0423     error = ps3stor_setup(dev, ps3disk_interrupt);
0424     if (error)
0425         goto fail_free_bounce;
0426 
0427     ps3disk_identify(dev);
0428 
0429     error = blk_mq_alloc_sq_tag_set(&priv->tag_set, &ps3disk_mq_ops, 1,
0430                     BLK_MQ_F_SHOULD_MERGE);
0431     if (error)
0432         goto fail_teardown;
0433 
0434     gendisk = blk_mq_alloc_disk(&priv->tag_set, dev);
0435     if (IS_ERR(gendisk)) {
0436         dev_err(&dev->sbd.core, "%s:%u: blk_mq_alloc_disk failed\n",
0437             __func__, __LINE__);
0438         error = PTR_ERR(gendisk);
0439         goto fail_free_tag_set;
0440     }
0441 
0442     queue = gendisk->queue;
0443 
0444     blk_queue_max_hw_sectors(queue, dev->bounce_size >> 9);
0445     blk_queue_dma_alignment(queue, dev->blk_size-1);
0446     blk_queue_logical_block_size(queue, dev->blk_size);
0447 
0448     blk_queue_write_cache(queue, true, false);
0449 
0450     blk_queue_max_segments(queue, -1);
0451     blk_queue_max_segment_size(queue, dev->bounce_size);
0452 
0453     priv->gendisk = gendisk;
0454     gendisk->major = ps3disk_major;
0455     gendisk->first_minor = devidx * PS3DISK_MINORS;
0456     gendisk->minors = PS3DISK_MINORS;
0457     gendisk->fops = &ps3disk_fops;
0458     gendisk->private_data = dev;
0459     snprintf(gendisk->disk_name, sizeof(gendisk->disk_name), PS3DISK_NAME,
0460          devidx+'a');
0461     priv->blocking_factor = dev->blk_size >> 9;
0462     set_capacity(gendisk,
0463              dev->regions[dev->region_idx].size*priv->blocking_factor);
0464 
0465     dev_info(&dev->sbd.core,
0466          "%s is a %s (%llu MiB total, %llu MiB for OtherOS)\n",
0467          gendisk->disk_name, priv->model, priv->raw_capacity >> 11,
0468          get_capacity(gendisk) >> 11);
0469 
0470     error = device_add_disk(&dev->sbd.core, gendisk, NULL);
0471     if (error)
0472         goto fail_cleanup_disk;
0473 
0474     return 0;
0475 fail_cleanup_disk:
0476     put_disk(gendisk);
0477 fail_free_tag_set:
0478     blk_mq_free_tag_set(&priv->tag_set);
0479 fail_teardown:
0480     ps3stor_teardown(dev);
0481 fail_free_bounce:
0482     kfree(dev->bounce_buf);
0483 fail_free_priv:
0484     kfree(priv);
0485     ps3_system_bus_set_drvdata(_dev, NULL);
0486 fail:
0487     mutex_lock(&ps3disk_mask_mutex);
0488     __clear_bit(devidx, &ps3disk_mask);
0489     mutex_unlock(&ps3disk_mask_mutex);
0490     return error;
0491 }
0492 
0493 static void ps3disk_remove(struct ps3_system_bus_device *_dev)
0494 {
0495     struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
0496     struct ps3disk_private *priv = ps3_system_bus_get_drvdata(&dev->sbd);
0497 
0498     mutex_lock(&ps3disk_mask_mutex);
0499     __clear_bit(MINOR(disk_devt(priv->gendisk)) / PS3DISK_MINORS,
0500             &ps3disk_mask);
0501     mutex_unlock(&ps3disk_mask_mutex);
0502     del_gendisk(priv->gendisk);
0503     put_disk(priv->gendisk);
0504     blk_mq_free_tag_set(&priv->tag_set);
0505     dev_notice(&dev->sbd.core, "Synchronizing disk cache\n");
0506     ps3disk_sync_cache(dev);
0507     ps3stor_teardown(dev);
0508     kfree(dev->bounce_buf);
0509     kfree(priv);
0510     ps3_system_bus_set_drvdata(_dev, NULL);
0511 }
0512 
0513 static struct ps3_system_bus_driver ps3disk = {
0514     .match_id   = PS3_MATCH_ID_STOR_DISK,
0515     .core.name  = DEVICE_NAME,
0516     .core.owner = THIS_MODULE,
0517     .probe      = ps3disk_probe,
0518     .remove     = ps3disk_remove,
0519     .shutdown   = ps3disk_remove,
0520 };
0521 
0522 
0523 static int __init ps3disk_init(void)
0524 {
0525     int error;
0526 
0527     if (!firmware_has_feature(FW_FEATURE_PS3_LV1))
0528         return -ENODEV;
0529 
0530     error = register_blkdev(0, DEVICE_NAME);
0531     if (error <= 0) {
0532         printk(KERN_ERR "%s:%u: register_blkdev failed %d\n", __func__,
0533                __LINE__, error);
0534         return error;
0535     }
0536     ps3disk_major = error;
0537 
0538     pr_info("%s:%u: registered block device major %d\n", __func__,
0539         __LINE__, ps3disk_major);
0540 
0541     error = ps3_system_bus_driver_register(&ps3disk);
0542     if (error)
0543         unregister_blkdev(ps3disk_major, DEVICE_NAME);
0544 
0545     return error;
0546 }
0547 
0548 static void __exit ps3disk_exit(void)
0549 {
0550     ps3_system_bus_driver_unregister(&ps3disk);
0551     unregister_blkdev(ps3disk_major, DEVICE_NAME);
0552 }
0553 
0554 module_init(ps3disk_init);
0555 module_exit(ps3disk_exit);
0556 
0557 MODULE_LICENSE("GPL");
0558 MODULE_DESCRIPTION("PS3 Disk Storage Driver");
0559 MODULE_AUTHOR("Sony Corporation");
0560 MODULE_ALIAS(PS3_MODULE_ALIAS_STOR_DISK);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!