tests/libqos/sdhci.c

   1 /*
   2  * libqos driver framework
   3  *
   4  * Copyright (c) 2018 Emanuele Giuseppe Esposito <e.emanuelegiuseppe@gmail.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License version 2 as published by the Free Software Foundation.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, see <http://www.gnu.org/licenses/>
  17  */
  18
  19 #include "qemu/osdep.h"
  20 #include "libqtest.h"
  21 #include "libqos/qgraph.h"
  22 #include "pci.h"
  23 #include "sdhci.h"
  24 #include "hw/pci/pci.h"
  25
  26 static void set_qsdhci_fields(QSDHCI *s, uint8_t version, uint8_t baseclock,
  27                               bool sdma, uint64_t reg)
  28 {
  29     s->props.version = version;
  30     s->props.baseclock = baseclock;
  31     s->props.capab.sdma = sdma;
  32     s->props.capab.reg = reg;
  33 }
  34
  35 /* Memory mapped implementation of QSDHCI */
  36
  37 static uint16_t sdhci_mm_readw(QSDHCI *s, uint32_t reg)
  38 {
  39     QSDHCI_MemoryMapped *smm = container_of(s, QSDHCI_MemoryMapped, sdhci);
  40     return qtest_readw(smm->qts, smm->addr + reg);
  41 }
  42
  43 static uint64_t sdhci_mm_readq(QSDHCI *s, uint32_t reg)
  44 {
  45     QSDHCI_MemoryMapped *smm = container_of(s, QSDHCI_MemoryMapped, sdhci);
  46     return qtest_readq(smm->qts, smm->addr + reg);
  47 }
  48
  49 static void sdhci_mm_writeq(QSDHCI *s, uint32_t reg, uint64_t val)
  50 {
  51     QSDHCI_MemoryMapped *smm = container_of(s, QSDHCI_MemoryMapped, sdhci);
  52     qtest_writeq(smm->qts, smm->addr + reg, val);
  53 }
  54
  55 static void *sdhci_mm_get_driver(void *obj, const char *interface)
  56 {
  57     QSDHCI_MemoryMapped *smm = obj;
  58     if (!g_strcmp0(interface, "sdhci")) {
  59         return &smm->sdhci;
  60     }
  61     fprintf(stderr, "%s not present in generic-sdhci\n", interface);
  62     g_assert_not_reached();
  63 }
  64
  65 void qos_init_sdhci_mm(QSDHCI_MemoryMapped *sdhci, QTestState *qts,
  66                        uint32_t addr, QSDHCIProperties *common)
  67 {
  68     sdhci->obj.get_driver = sdhci_mm_get_driver;
  69     sdhci->sdhci.readw = sdhci_mm_readw;
  70     sdhci->sdhci.readq = sdhci_mm_readq;
  71     sdhci->sdhci.writeq = sdhci_mm_writeq;
  72     memcpy(&sdhci->sdhci.props, common, sizeof(QSDHCIProperties));
  73     sdhci->addr = addr;
  74     sdhci->qts = qts;
  75 }
  76
  77 /* PCI implementation of QSDHCI */
  78
  79 static uint16_t sdhci_pci_readw(QSDHCI *s, uint32_t reg)
  80 {
  81     QSDHCI_PCI *spci = container_of(s, QSDHCI_PCI, sdhci);
  82     return qpci_io_readw(&spci->dev, spci->mem_bar, reg);
  83 }
  84
  85 static uint64_t sdhci_pci_readq(QSDHCI *s, uint32_t reg)
  86 {
  87     QSDHCI_PCI *spci = container_of(s, QSDHCI_PCI, sdhci);
  88     return qpci_io_readq(&spci->dev, spci->mem_bar, reg);
  89 }
  90
  91 static void sdhci_pci_writeq(QSDHCI *s, uint32_t reg, uint64_t val)
  92 {
  93     QSDHCI_PCI *spci = container_of(s, QSDHCI_PCI, sdhci);
  94     return qpci_io_writeq(&spci->dev, spci->mem_bar, reg, val);
  95 }
  96
  97 static void *sdhci_pci_get_driver(void *object, const char *interface)
  98 {
  99     QSDHCI_PCI *spci = object;
 100     if (!g_strcmp0(interface, "sdhci")) {
 101         return &spci->sdhci;
 102     }
 103
 104     fprintf(stderr, "%s not present in sdhci-pci\n", interface);
 105     g_assert_not_reached();
 106 }
 107
 108 static void sdhci_pci_start_hw(QOSGraphObject *obj)
 109 {
 110     QSDHCI_PCI *spci = (QSDHCI_PCI *)obj;
 111     qpci_device_enable(&spci->dev);
 112 }
 113
 114 static void sdhci_destructor(QOSGraphObject *obj)
 115 {
 116     QSDHCI_PCI *spci = (QSDHCI_PCI *)obj;
 117     qpci_iounmap(&spci->dev, spci->mem_bar);
 118 }
 119
 120 static void *sdhci_pci_create(void *pci_bus, QGuestAllocator *alloc, void *addr)
 121 {
 122     QSDHCI_PCI *spci = g_new0(QSDHCI_PCI, 1);
 123     QPCIBus *bus = pci_bus;
 124     uint64_t barsize;
 125
 126     qpci_device_init(&spci->dev, bus, addr);
 127     spci->mem_bar = qpci_iomap(&spci->dev, 0, &barsize);
 128     spci->sdhci.readw = sdhci_pci_readw;
 129     spci->sdhci.readq = sdhci_pci_readq;
 130     spci->sdhci.writeq = sdhci_pci_writeq;
 131     set_qsdhci_fields(&spci->sdhci, 2, 0, 1, 0x057834b4);
 132
 133     spci->obj.get_driver = sdhci_pci_get_driver;
 134     spci->obj.start_hw = sdhci_pci_start_hw;
 135     spci->obj.destructor = sdhci_destructor;
 136     return &spci->obj;
 137 }
 138
 139 static void qsdhci_register_nodes(void)
 140 {
 141     QPCIAddress addr = {
 142         .devfn = QPCI_DEVFN(4, 0),
 143         .vendor_id = PCI_VENDOR_ID_REDHAT,
 144         .device_id = PCI_DEVICE_ID_REDHAT_SDHCI,
 145     };
 146
 147     QOSGraphEdgeOptions opts = {
 148         .extra_device_opts = "addr=04.0",
 149     };
 150
 151     /* generic-sdhci */
 152     qos_node_create_driver("generic-sdhci", NULL);
 153     qos_node_produces("generic-sdhci", "sdhci");
 154
 155     /* sdhci-pci */
 156     add_qpci_address(&opts, &addr);
 157     qos_node_create_driver("sdhci-pci", sdhci_pci_create);
 158     qos_node_produces("sdhci-pci", "sdhci");
 159     qos_node_consumes("sdhci-pci", "pci-bus", &opts);
 160
 161 }
 162
 163 libqos_init(qsdhci_register_nodes);