virtio_blk.c 3.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2018, Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>
  4. * Copyright (C) 2018, Bin Meng <bmeng.cn@gmail.com>
  5. */
  6. #include <common.h>
  7. #include <blk.h>
  8. #include <dm.h>
  9. #include <virtio_types.h>
  10. #include <virtio.h>
  11. #include <virtio_ring.h>
  12. #include "virtio_blk.h"
  13. struct virtio_blk_priv {
  14. struct virtqueue *vq;
  15. };
  16. static ulong virtio_blk_do_req(struct udevice *dev, u64 sector,
  17. lbaint_t blkcnt, void *buffer, u32 type)
  18. {
  19. struct virtio_blk_priv *priv = dev_get_priv(dev);
  20. unsigned int num_out = 0, num_in = 0;
  21. struct virtio_sg *sgs[3];
  22. u8 status;
  23. int ret;
  24. struct virtio_blk_outhdr out_hdr = {
  25. .type = cpu_to_virtio32(dev, type),
  26. .sector = cpu_to_virtio64(dev, sector),
  27. };
  28. struct virtio_sg hdr_sg = { &out_hdr, sizeof(out_hdr) };
  29. struct virtio_sg data_sg = { buffer, blkcnt * 512 };
  30. struct virtio_sg status_sg = { &status, sizeof(status) };
  31. sgs[num_out++] = &hdr_sg;
  32. if (type & VIRTIO_BLK_T_OUT)
  33. sgs[num_out++] = &data_sg;
  34. else
  35. sgs[num_out + num_in++] = &data_sg;
  36. sgs[num_out + num_in++] = &status_sg;
  37. ret = virtqueue_add(priv->vq, sgs, num_out, num_in);
  38. if (ret)
  39. return ret;
  40. virtqueue_kick(priv->vq);
  41. while (!virtqueue_get_buf(priv->vq, NULL))
  42. ;
  43. return status == VIRTIO_BLK_S_OK ? blkcnt : -EIO;
  44. }
  45. static ulong virtio_blk_read(struct udevice *dev, lbaint_t start,
  46. lbaint_t blkcnt, void *buffer)
  47. {
  48. return virtio_blk_do_req(dev, start, blkcnt, buffer,
  49. VIRTIO_BLK_T_IN);
  50. }
  51. static ulong virtio_blk_write(struct udevice *dev, lbaint_t start,
  52. lbaint_t blkcnt, const void *buffer)
  53. {
  54. return virtio_blk_do_req(dev, start, blkcnt, (void *)buffer,
  55. VIRTIO_BLK_T_OUT);
  56. }
  57. static int virtio_blk_bind(struct udevice *dev)
  58. {
  59. struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(dev->parent);
  60. struct blk_desc *desc = dev_get_uclass_platdata(dev);
  61. int devnum;
  62. desc->if_type = IF_TYPE_VIRTIO;
  63. /*
  64. * Initialize the devnum to -ENODEV. This is to make sure that
  65. * blk_next_free_devnum() works as expected, since the default
  66. * value 0 is a valid devnum.
  67. */
  68. desc->devnum = -ENODEV;
  69. devnum = blk_next_free_devnum(IF_TYPE_VIRTIO);
  70. if (devnum < 0)
  71. return devnum;
  72. desc->devnum = devnum;
  73. desc->part_type = PART_TYPE_UNKNOWN;
  74. /*
  75. * virtio mmio transport supplies string identification for us,
  76. * while pci trnasport uses a 2-byte subvendor value.
  77. */
  78. if (uc_priv->vendor >> 16)
  79. sprintf(desc->vendor, "%s", (char *)&uc_priv->vendor);
  80. else
  81. sprintf(desc->vendor, "%04x", uc_priv->vendor);
  82. desc->bdev = dev;
  83. /* Indicate what driver features we support */
  84. virtio_driver_features_init(uc_priv, NULL, 0, NULL, 0);
  85. return 0;
  86. }
  87. static int virtio_blk_probe(struct udevice *dev)
  88. {
  89. struct virtio_blk_priv *priv = dev_get_priv(dev);
  90. struct blk_desc *desc = dev_get_uclass_platdata(dev);
  91. u64 cap;
  92. int ret;
  93. ret = virtio_find_vqs(dev, 1, &priv->vq);
  94. if (ret)
  95. return ret;
  96. desc->blksz = 512;
  97. virtio_cread(dev, struct virtio_blk_config, capacity, &cap);
  98. desc->lba = cap;
  99. return 0;
  100. }
  101. static const struct blk_ops virtio_blk_ops = {
  102. .read = virtio_blk_read,
  103. .write = virtio_blk_write,
  104. };
  105. U_BOOT_DRIVER(virtio_blk) = {
  106. .name = VIRTIO_BLK_DRV_NAME,
  107. .id = UCLASS_BLK,
  108. .ops = &virtio_blk_ops,
  109. .bind = virtio_blk_bind,
  110. .probe = virtio_blk_probe,
  111. .remove = virtio_reset,
  112. .priv_auto_alloc_size = sizeof(struct virtio_blk_priv),
  113. .flags = DM_FLAG_ACTIVE_DMA,
  114. };