hw/sd/core.c

   1 /*
   2  * SD card bus interface code.
   3  *
   4  * Copyright (c) 2015 Linaro Limited
   5  *
   6  * Author:
   7  *  Peter Maydell <peter.maydell@linaro.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms and conditions of the GNU General Public License,
  11  * version 2 or later, as published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope it will be useful, but WITHOUT
  14  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  16  * more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along with
  19  * this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include "qemu/osdep.h"
  23 #include "hw/qdev-core.h"
  24 #include "sysemu/block-backend.h"
  25 #include "hw/sd/sd.h"
  26 #include "trace.h"
  27
  28 static inline const char *sdbus_name(SDBus *sdbus)
  29 {
  30     return sdbus->qbus.name;
  31 }
  32
  33 static SDState *get_card(SDBus *sdbus)
  34 {
  35     /* We only ever have one child on the bus so just return it */
  36     BusChild *kid = QTAILQ_FIRST(&sdbus->qbus.children);
  37
  38     if (!kid) {
  39         return NULL;
  40     }
  41     return SD_CARD(kid->child);
  42 }
  43
  44 void sdbus_set_voltage(SDBus *sdbus, uint16_t millivolts)
  45 {
  46     SDState *card = get_card(sdbus);
  47
  48     trace_sdbus_set_voltage(sdbus_name(sdbus), millivolts);
  49     if (card) {
  50         SDCardClass *sc = SD_CARD_GET_CLASS(card);
  51
  52         assert(sc->set_voltage);
  53         sc->set_voltage(card, millivolts);
  54     }
  55 }
  56
  57 int sdbus_do_command(SDBus *sdbus, SDRequest *req, uint8_t *response)
  58 {
  59     SDState *card = get_card(sdbus);
  60
  61     trace_sdbus_command(sdbus_name(sdbus), req->cmd, req->arg, req->crc);
  62     if (card) {
  63         SDCardClass *sc = SD_CARD_GET_CLASS(card);
  64
  65         return sc->do_command(card, req, response);
  66     }
  67
  68     return 0;
  69 }
  70
  71 void sdbus_write_data(SDBus *sdbus, uint8_t value)
  72 {
  73     SDState *card = get_card(sdbus);
  74
  75     trace_sdbus_write(sdbus_name(sdbus), value);
  76     if (card) {
  77         SDCardClass *sc = SD_CARD_GET_CLASS(card);
  78
  79         sc->write_data(card, value);
  80     }
  81 }
  82
  83 uint8_t sdbus_read_data(SDBus *sdbus)
  84 {
  85     SDState *card = get_card(sdbus);
  86     uint8_t value = 0;
  87
  88     if (card) {
  89         SDCardClass *sc = SD_CARD_GET_CLASS(card);
  90
  91         value = sc->read_data(card);
  92     }
  93     trace_sdbus_read(sdbus_name(sdbus), value);
  94
  95     return value;
  96 }
  97
  98 bool sdbus_data_ready(SDBus *sdbus)
  99 {
 100     SDState *card = get_card(sdbus);
 101
 102     if (card) {
 103         SDCardClass *sc = SD_CARD_GET_CLASS(card);
 104
 105         return sc->data_ready(card);
 106     }
 107
 108     return false;
 109 }
 110
 111 bool sdbus_get_inserted(SDBus *sdbus)
 112 {
 113     SDState *card = get_card(sdbus);
 114
 115     if (card) {
 116         SDCardClass *sc = SD_CARD_GET_CLASS(card);
 117
 118         return sc->get_inserted(card);
 119     }
 120
 121     return false;
 122 }
 123
 124 bool sdbus_get_readonly(SDBus *sdbus)
 125 {
 126     SDState *card = get_card(sdbus);
 127
 128     if (card) {
 129         SDCardClass *sc = SD_CARD_GET_CLASS(card);
 130
 131         return sc->get_readonly(card);
 132     }
 133
 134     return false;
 135 }
 136
 137 void sdbus_set_inserted(SDBus *sdbus, bool inserted)
 138 {
 139     SDBusClass *sbc = SD_BUS_GET_CLASS(sdbus);
 140     BusState *qbus = BUS(sdbus);
 141
 142     if (sbc->set_inserted) {
 143         sbc->set_inserted(qbus->parent, inserted);
 144     }
 145 }
 146
 147 void sdbus_set_readonly(SDBus *sdbus, bool readonly)
 148 {
 149     SDBusClass *sbc = SD_BUS_GET_CLASS(sdbus);
 150     BusState *qbus = BUS(sdbus);
 151
 152     if (sbc->set_readonly) {
 153         sbc->set_readonly(qbus->parent, readonly);
 154     }
 155 }
 156
 157 void sdbus_reparent_card(SDBus *from, SDBus *to)
 158 {
 159     SDState *card = get_card(from);
 160     SDCardClass *sc;
 161     bool readonly;
 162
 163     /* We directly reparent the card object rather than implementing this
 164      * as a hotpluggable connection because we don't want to expose SD cards
 165      * to users as being hotpluggable, and we can get away with it in this
 166      * limited use case. This could perhaps be implemented more cleanly in
 167      * future by adding support to the hotplug infrastructure for "device
 168      * can be hotplugged only via code, not by user".
 169      */
 170
 171     if (!card) {
 172         return;
 173     }
 174
 175     sc = SD_CARD_GET_CLASS(card);
 176     readonly = sc->get_readonly(card);
 177
 178     sdbus_set_inserted(from, false);
 179     qdev_set_parent_bus(DEVICE(card), &to->qbus);
 180     sdbus_set_inserted(to, true);
 181     sdbus_set_readonly(to, readonly);
 182 }
 183
 184 static const TypeInfo sd_bus_info = {
 185     .name = TYPE_SD_BUS,
 186     .parent = TYPE_BUS,
 187     .instance_size = sizeof(SDBus),
 188     .class_size = sizeof(SDBusClass),
 189 };
 190
 191 static void sd_bus_register_types(void)
 192 {
 193     type_register_static(&sd_bus_info);
 194 }
 195
 196 type_init(sd_bus_register_types)