meson: convert hw/vfio
[qemu.git] / 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 "hw/sd/sd.h"
25 #include "qemu/module.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 uint8_t sdbus_get_dat_lines(SDBus *sdbus)
45 {
46 SDState *slave = get_card(sdbus);
47 uint8_t dat_lines = 0b1111; /* 4 bit bus width */
48
49 if (slave) {
50 SDCardClass *sc = SD_CARD_GET_CLASS(slave);
51
52 if (sc->get_dat_lines) {
53 dat_lines = sc->get_dat_lines(slave);
54 }
55 }
56 trace_sdbus_get_dat_lines(sdbus_name(sdbus), dat_lines);
57
58 return dat_lines;
59 }
60
61 bool sdbus_get_cmd_line(SDBus *sdbus)
62 {
63 SDState *slave = get_card(sdbus);
64 bool cmd_line = true;
65
66 if (slave) {
67 SDCardClass *sc = SD_CARD_GET_CLASS(slave);
68
69 if (sc->get_cmd_line) {
70 cmd_line = sc->get_cmd_line(slave);
71 }
72 }
73 trace_sdbus_get_cmd_line(sdbus_name(sdbus), cmd_line);
74
75 return cmd_line;
76 }
77
78 void sdbus_set_voltage(SDBus *sdbus, uint16_t millivolts)
79 {
80 SDState *card = get_card(sdbus);
81
82 trace_sdbus_set_voltage(sdbus_name(sdbus), millivolts);
83 if (card) {
84 SDCardClass *sc = SD_CARD_GET_CLASS(card);
85
86 assert(sc->set_voltage);
87 sc->set_voltage(card, millivolts);
88 }
89 }
90
91 int sdbus_do_command(SDBus *sdbus, SDRequest *req, uint8_t *response)
92 {
93 SDState *card = get_card(sdbus);
94
95 trace_sdbus_command(sdbus_name(sdbus), req->cmd, req->arg);
96 if (card) {
97 SDCardClass *sc = SD_CARD_GET_CLASS(card);
98
99 return sc->do_command(card, req, response);
100 }
101
102 return 0;
103 }
104
105 void sdbus_write_data(SDBus *sdbus, uint8_t value)
106 {
107 SDState *card = get_card(sdbus);
108
109 trace_sdbus_write(sdbus_name(sdbus), value);
110 if (card) {
111 SDCardClass *sc = SD_CARD_GET_CLASS(card);
112
113 sc->write_data(card, value);
114 }
115 }
116
117 uint8_t sdbus_read_data(SDBus *sdbus)
118 {
119 SDState *card = get_card(sdbus);
120 uint8_t value = 0;
121
122 if (card) {
123 SDCardClass *sc = SD_CARD_GET_CLASS(card);
124
125 value = sc->read_data(card);
126 }
127 trace_sdbus_read(sdbus_name(sdbus), value);
128
129 return value;
130 }
131
132 bool sdbus_data_ready(SDBus *sdbus)
133 {
134 SDState *card = get_card(sdbus);
135
136 if (card) {
137 SDCardClass *sc = SD_CARD_GET_CLASS(card);
138
139 return sc->data_ready(card);
140 }
141
142 return false;
143 }
144
145 bool sdbus_get_inserted(SDBus *sdbus)
146 {
147 SDState *card = get_card(sdbus);
148
149 if (card) {
150 SDCardClass *sc = SD_CARD_GET_CLASS(card);
151
152 return sc->get_inserted(card);
153 }
154
155 return false;
156 }
157
158 bool sdbus_get_readonly(SDBus *sdbus)
159 {
160 SDState *card = get_card(sdbus);
161
162 if (card) {
163 SDCardClass *sc = SD_CARD_GET_CLASS(card);
164
165 return sc->get_readonly(card);
166 }
167
168 return false;
169 }
170
171 void sdbus_set_inserted(SDBus *sdbus, bool inserted)
172 {
173 SDBusClass *sbc = SD_BUS_GET_CLASS(sdbus);
174 BusState *qbus = BUS(sdbus);
175
176 if (sbc->set_inserted) {
177 sbc->set_inserted(qbus->parent, inserted);
178 }
179 }
180
181 void sdbus_set_readonly(SDBus *sdbus, bool readonly)
182 {
183 SDBusClass *sbc = SD_BUS_GET_CLASS(sdbus);
184 BusState *qbus = BUS(sdbus);
185
186 if (sbc->set_readonly) {
187 sbc->set_readonly(qbus->parent, readonly);
188 }
189 }
190
191 void sdbus_reparent_card(SDBus *from, SDBus *to)
192 {
193 SDState *card = get_card(from);
194 SDCardClass *sc;
195 bool readonly;
196
197 /* We directly reparent the card object rather than implementing this
198 * as a hotpluggable connection because we don't want to expose SD cards
199 * to users as being hotpluggable, and we can get away with it in this
200 * limited use case. This could perhaps be implemented more cleanly in
201 * future by adding support to the hotplug infrastructure for "device
202 * can be hotplugged only via code, not by user".
203 */
204
205 if (!card) {
206 return;
207 }
208
209 sc = SD_CARD_GET_CLASS(card);
210 readonly = sc->get_readonly(card);
211
212 sdbus_set_inserted(from, false);
213 qdev_set_parent_bus(DEVICE(card), &to->qbus);
214 sdbus_set_inserted(to, true);
215 sdbus_set_readonly(to, readonly);
216 }
217
218 static const TypeInfo sd_bus_info = {
219 .name = TYPE_SD_BUS,
220 .parent = TYPE_BUS,
221 .instance_size = sizeof(SDBus),
222 .class_size = sizeof(SDBusClass),
223 };
224
225 static void sd_bus_register_types(void)
226 {
227 type_register_static(&sd_bus_info);
228 }
229
230 type_init(sd_bus_register_types)