virtio_mmio.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416
  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. * VirtIO memory-maped I/O transport driver
  7. * Ported from Linux drivers/virtio/virtio_mmio.c
  8. */
  9. #include <common.h>
  10. #include <dm.h>
  11. #include <log.h>
  12. #include <virtio_types.h>
  13. #include <virtio.h>
  14. #include <virtio_ring.h>
  15. #include <linux/bug.h>
  16. #include <linux/compat.h>
  17. #include <linux/err.h>
  18. #include <linux/io.h>
  19. #include "virtio_mmio.h"
  20. static int virtio_mmio_get_config(struct udevice *udev, unsigned int offset,
  21. void *buf, unsigned int len)
  22. {
  23. struct virtio_mmio_priv *priv = dev_get_priv(udev);
  24. void __iomem *base = priv->base + VIRTIO_MMIO_CONFIG;
  25. u8 b;
  26. __le16 w;
  27. __le32 l;
  28. if (priv->version == 1) {
  29. u8 *ptr = buf;
  30. int i;
  31. for (i = 0; i < len; i++)
  32. ptr[i] = readb(base + offset + i);
  33. return 0;
  34. }
  35. switch (len) {
  36. case 1:
  37. b = readb(base + offset);
  38. memcpy(buf, &b, sizeof(b));
  39. break;
  40. case 2:
  41. w = cpu_to_le16(readw(base + offset));
  42. memcpy(buf, &w, sizeof(w));
  43. break;
  44. case 4:
  45. l = cpu_to_le32(readl(base + offset));
  46. memcpy(buf, &l, sizeof(l));
  47. break;
  48. case 8:
  49. l = cpu_to_le32(readl(base + offset));
  50. memcpy(buf, &l, sizeof(l));
  51. l = cpu_to_le32(readl(base + offset + sizeof(l)));
  52. memcpy(buf + sizeof(l), &l, sizeof(l));
  53. break;
  54. default:
  55. WARN_ON(true);
  56. }
  57. return 0;
  58. }
  59. static int virtio_mmio_set_config(struct udevice *udev, unsigned int offset,
  60. const void *buf, unsigned int len)
  61. {
  62. struct virtio_mmio_priv *priv = dev_get_priv(udev);
  63. void __iomem *base = priv->base + VIRTIO_MMIO_CONFIG;
  64. u8 b;
  65. __le16 w;
  66. __le32 l;
  67. if (priv->version == 1) {
  68. const u8 *ptr = buf;
  69. int i;
  70. for (i = 0; i < len; i++)
  71. writeb(ptr[i], base + offset + i);
  72. return 0;
  73. }
  74. switch (len) {
  75. case 1:
  76. memcpy(&b, buf, sizeof(b));
  77. writeb(b, base + offset);
  78. break;
  79. case 2:
  80. memcpy(&w, buf, sizeof(w));
  81. writew(le16_to_cpu(w), base + offset);
  82. break;
  83. case 4:
  84. memcpy(&l, buf, sizeof(l));
  85. writel(le32_to_cpu(l), base + offset);
  86. break;
  87. case 8:
  88. memcpy(&l, buf, sizeof(l));
  89. writel(le32_to_cpu(l), base + offset);
  90. memcpy(&l, buf + sizeof(l), sizeof(l));
  91. writel(le32_to_cpu(l), base + offset + sizeof(l));
  92. break;
  93. default:
  94. WARN_ON(true);
  95. }
  96. return 0;
  97. }
  98. static int virtio_mmio_generation(struct udevice *udev, u32 *counter)
  99. {
  100. struct virtio_mmio_priv *priv = dev_get_priv(udev);
  101. if (priv->version == 1)
  102. *counter = 0;
  103. else
  104. *counter = readl(priv->base + VIRTIO_MMIO_CONFIG_GENERATION);
  105. return 0;
  106. }
  107. static int virtio_mmio_get_status(struct udevice *udev, u8 *status)
  108. {
  109. struct virtio_mmio_priv *priv = dev_get_priv(udev);
  110. *status = readl(priv->base + VIRTIO_MMIO_STATUS) & 0xff;
  111. return 0;
  112. }
  113. static int virtio_mmio_set_status(struct udevice *udev, u8 status)
  114. {
  115. struct virtio_mmio_priv *priv = dev_get_priv(udev);
  116. /* We should never be setting status to 0 */
  117. WARN_ON(status == 0);
  118. writel(status, priv->base + VIRTIO_MMIO_STATUS);
  119. return 0;
  120. }
  121. static int virtio_mmio_reset(struct udevice *udev)
  122. {
  123. struct virtio_mmio_priv *priv = dev_get_priv(udev);
  124. /* 0 status means a reset */
  125. writel(0, priv->base + VIRTIO_MMIO_STATUS);
  126. return 0;
  127. }
  128. static int virtio_mmio_get_features(struct udevice *udev, u64 *features)
  129. {
  130. struct virtio_mmio_priv *priv = dev_get_priv(udev);
  131. writel(1, priv->base + VIRTIO_MMIO_DEVICE_FEATURES_SEL);
  132. *features = readl(priv->base + VIRTIO_MMIO_DEVICE_FEATURES);
  133. *features <<= 32;
  134. writel(0, priv->base + VIRTIO_MMIO_DEVICE_FEATURES_SEL);
  135. *features |= readl(priv->base + VIRTIO_MMIO_DEVICE_FEATURES);
  136. return 0;
  137. }
  138. static int virtio_mmio_set_features(struct udevice *udev)
  139. {
  140. struct virtio_mmio_priv *priv = dev_get_priv(udev);
  141. struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
  142. /* Make sure there is are no mixed devices */
  143. if (priv->version == 2 && uc_priv->legacy) {
  144. debug("New virtio-mmio devices (version 2) must provide VIRTIO_F_VERSION_1 feature!\n");
  145. return -EINVAL;
  146. }
  147. writel(1, priv->base + VIRTIO_MMIO_DRIVER_FEATURES_SEL);
  148. writel((u32)(uc_priv->features >> 32),
  149. priv->base + VIRTIO_MMIO_DRIVER_FEATURES);
  150. writel(0, priv->base + VIRTIO_MMIO_DRIVER_FEATURES_SEL);
  151. writel((u32)uc_priv->features,
  152. priv->base + VIRTIO_MMIO_DRIVER_FEATURES);
  153. return 0;
  154. }
  155. static struct virtqueue *virtio_mmio_setup_vq(struct udevice *udev,
  156. unsigned int index)
  157. {
  158. struct virtio_mmio_priv *priv = dev_get_priv(udev);
  159. struct virtqueue *vq;
  160. unsigned int num;
  161. int err;
  162. /* Select the queue we're interested in */
  163. writel(index, priv->base + VIRTIO_MMIO_QUEUE_SEL);
  164. /* Queue shouldn't already be set up */
  165. if (readl(priv->base + (priv->version == 1 ?
  166. VIRTIO_MMIO_QUEUE_PFN : VIRTIO_MMIO_QUEUE_READY))) {
  167. err = -ENOENT;
  168. goto error_available;
  169. }
  170. num = readl(priv->base + VIRTIO_MMIO_QUEUE_NUM_MAX);
  171. if (num == 0) {
  172. err = -ENOENT;
  173. goto error_new_virtqueue;
  174. }
  175. /* Create the vring */
  176. vq = vring_create_virtqueue(index, num, VIRTIO_MMIO_VRING_ALIGN, udev);
  177. if (!vq) {
  178. err = -ENOMEM;
  179. goto error_new_virtqueue;
  180. }
  181. /* Activate the queue */
  182. writel(virtqueue_get_vring_size(vq),
  183. priv->base + VIRTIO_MMIO_QUEUE_NUM);
  184. if (priv->version == 1) {
  185. u64 q_pfn = virtqueue_get_desc_addr(vq) >> PAGE_SHIFT;
  186. /*
  187. * virtio-mmio v1 uses a 32bit QUEUE PFN. If we have something
  188. * that doesn't fit in 32bit, fail the setup rather than
  189. * pretending to be successful.
  190. */
  191. if (q_pfn >> 32) {
  192. debug("platform bug: legacy virtio-mmio must not be used with RAM above 0x%llxGB\n",
  193. 0x1ULL << (32 + PAGE_SHIFT - 30));
  194. err = -E2BIG;
  195. goto error_bad_pfn;
  196. }
  197. writel(PAGE_SIZE, priv->base + VIRTIO_MMIO_QUEUE_ALIGN);
  198. writel(q_pfn, priv->base + VIRTIO_MMIO_QUEUE_PFN);
  199. } else {
  200. u64 addr;
  201. addr = virtqueue_get_desc_addr(vq);
  202. writel((u32)addr, priv->base + VIRTIO_MMIO_QUEUE_DESC_LOW);
  203. writel((u32)(addr >> 32),
  204. priv->base + VIRTIO_MMIO_QUEUE_DESC_HIGH);
  205. addr = virtqueue_get_avail_addr(vq);
  206. writel((u32)addr, priv->base + VIRTIO_MMIO_QUEUE_AVAIL_LOW);
  207. writel((u32)(addr >> 32),
  208. priv->base + VIRTIO_MMIO_QUEUE_AVAIL_HIGH);
  209. addr = virtqueue_get_used_addr(vq);
  210. writel((u32)addr, priv->base + VIRTIO_MMIO_QUEUE_USED_LOW);
  211. writel((u32)(addr >> 32),
  212. priv->base + VIRTIO_MMIO_QUEUE_USED_HIGH);
  213. writel(1, priv->base + VIRTIO_MMIO_QUEUE_READY);
  214. }
  215. return vq;
  216. error_bad_pfn:
  217. vring_del_virtqueue(vq);
  218. error_new_virtqueue:
  219. if (priv->version == 1) {
  220. writel(0, priv->base + VIRTIO_MMIO_QUEUE_PFN);
  221. } else {
  222. writel(0, priv->base + VIRTIO_MMIO_QUEUE_READY);
  223. WARN_ON(readl(priv->base + VIRTIO_MMIO_QUEUE_READY));
  224. }
  225. error_available:
  226. return ERR_PTR(err);
  227. }
  228. static void virtio_mmio_del_vq(struct virtqueue *vq)
  229. {
  230. struct virtio_mmio_priv *priv = dev_get_priv(vq->vdev);
  231. unsigned int index = vq->index;
  232. /* Select and deactivate the queue */
  233. writel(index, priv->base + VIRTIO_MMIO_QUEUE_SEL);
  234. if (priv->version == 1) {
  235. writel(0, priv->base + VIRTIO_MMIO_QUEUE_PFN);
  236. } else {
  237. writel(0, priv->base + VIRTIO_MMIO_QUEUE_READY);
  238. WARN_ON(readl(priv->base + VIRTIO_MMIO_QUEUE_READY));
  239. }
  240. vring_del_virtqueue(vq);
  241. }
  242. static int virtio_mmio_del_vqs(struct udevice *udev)
  243. {
  244. struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
  245. struct virtqueue *vq, *n;
  246. list_for_each_entry_safe(vq, n, &uc_priv->vqs, list)
  247. virtio_mmio_del_vq(vq);
  248. return 0;
  249. }
  250. static int virtio_mmio_find_vqs(struct udevice *udev, unsigned int nvqs,
  251. struct virtqueue *vqs[])
  252. {
  253. int i;
  254. for (i = 0; i < nvqs; ++i) {
  255. vqs[i] = virtio_mmio_setup_vq(udev, i);
  256. if (IS_ERR(vqs[i])) {
  257. virtio_mmio_del_vqs(udev);
  258. return PTR_ERR(vqs[i]);
  259. }
  260. }
  261. return 0;
  262. }
  263. static int virtio_mmio_notify(struct udevice *udev, struct virtqueue *vq)
  264. {
  265. struct virtio_mmio_priv *priv = dev_get_priv(udev);
  266. /*
  267. * We write the queue's selector into the notification register
  268. * to signal the other end
  269. */
  270. writel(vq->index, priv->base + VIRTIO_MMIO_QUEUE_NOTIFY);
  271. return 0;
  272. }
  273. static int virtio_mmio_ofdata_to_platdata(struct udevice *udev)
  274. {
  275. struct virtio_mmio_priv *priv = dev_get_priv(udev);
  276. priv->base = (void __iomem *)(ulong)dev_read_addr(udev);
  277. if (priv->base == (void __iomem *)FDT_ADDR_T_NONE)
  278. return -EINVAL;
  279. return 0;
  280. }
  281. static int virtio_mmio_probe(struct udevice *udev)
  282. {
  283. struct virtio_mmio_priv *priv = dev_get_priv(udev);
  284. struct virtio_dev_priv *uc_priv = dev_get_uclass_priv(udev);
  285. u32 magic;
  286. /* Check magic value */
  287. magic = readl(priv->base + VIRTIO_MMIO_MAGIC_VALUE);
  288. if (magic != ('v' | 'i' << 8 | 'r' << 16 | 't' << 24)) {
  289. debug("(%s): wrong magic value 0x%08x!\n", udev->name, magic);
  290. return 0;
  291. }
  292. /* Check device version */
  293. priv->version = readl(priv->base + VIRTIO_MMIO_VERSION);
  294. if (priv->version < 1 || priv->version > 2) {
  295. debug("(%s): version %d not supported!\n",
  296. udev->name, priv->version);
  297. return 0;
  298. }
  299. /* Check device ID */
  300. uc_priv->device = readl(priv->base + VIRTIO_MMIO_DEVICE_ID);
  301. if (uc_priv->device == 0) {
  302. /*
  303. * virtio-mmio device with an ID 0 is a (dummy) placeholder
  304. * with no function. End probing now with no error reported.
  305. */
  306. return 0;
  307. }
  308. uc_priv->vendor = readl(priv->base + VIRTIO_MMIO_VENDOR_ID);
  309. if (priv->version == 1)
  310. writel(PAGE_SIZE, priv->base + VIRTIO_MMIO_GUEST_PAGE_SIZE);
  311. debug("(%s): device (%d) vendor (%08x) version (%d)\n", udev->name,
  312. uc_priv->device, uc_priv->vendor, priv->version);
  313. return 0;
  314. }
  315. static const struct dm_virtio_ops virtio_mmio_ops = {
  316. .get_config = virtio_mmio_get_config,
  317. .set_config = virtio_mmio_set_config,
  318. .generation = virtio_mmio_generation,
  319. .get_status = virtio_mmio_get_status,
  320. .set_status = virtio_mmio_set_status,
  321. .reset = virtio_mmio_reset,
  322. .get_features = virtio_mmio_get_features,
  323. .set_features = virtio_mmio_set_features,
  324. .find_vqs = virtio_mmio_find_vqs,
  325. .del_vqs = virtio_mmio_del_vqs,
  326. .notify = virtio_mmio_notify,
  327. };
  328. static const struct udevice_id virtio_mmio_ids[] = {
  329. { .compatible = "virtio,mmio" },
  330. { }
  331. };
  332. U_BOOT_DRIVER(virtio_mmio) = {
  333. .name = "virtio-mmio",
  334. .id = UCLASS_VIRTIO,
  335. .of_match = virtio_mmio_ids,
  336. .ops = &virtio_mmio_ops,
  337. .probe = virtio_mmio_probe,
  338. .ofdata_to_platdata = virtio_mmio_ofdata_to_platdata,
  339. .priv_auto_alloc_size = sizeof(struct virtio_mmio_priv),
  340. };