Merge tag 'pull-hex-20221003' of https://github.com/quic/qemu into staging
[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 "qapi/error.h"
27 #include "trace.h"
28
29 static inline const char *sdbus_name(SDBus *sdbus)
30 {
31 return sdbus->qbus.name;
32 }
33
34 static SDState *get_card(SDBus *sdbus)
35 {
36 /* We only ever have one child on the bus so just return it */
37 BusChild *kid = QTAILQ_FIRST(&sdbus->qbus.children);
38
39 if (!kid) {
40 return NULL;
41 }
42 return SD_CARD(kid->child);
43 }
44
45 uint8_t sdbus_get_dat_lines(SDBus *sdbus)
46 {
47 SDState *slave = get_card(sdbus);
48 uint8_t dat_lines = 0b1111; /* 4 bit bus width */
49
50 if (slave) {
51 SDCardClass *sc = SD_CARD_GET_CLASS(slave);
52
53 if (sc->get_dat_lines) {
54 dat_lines = sc->get_dat_lines(slave);
55 }
56 }
57 trace_sdbus_get_dat_lines(sdbus_name(sdbus), dat_lines);
58
59 return dat_lines;
60 }
61
62 bool sdbus_get_cmd_line(SDBus *sdbus)
63 {
64 SDState *slave = get_card(sdbus);
65 bool cmd_line = true;
66
67 if (slave) {
68 SDCardClass *sc = SD_CARD_GET_CLASS(slave);
69
70 if (sc->get_cmd_line) {
71 cmd_line = sc->get_cmd_line(slave);
72 }
73 }
74 trace_sdbus_get_cmd_line(sdbus_name(sdbus), cmd_line);
75
76 return cmd_line;
77 }
78
79 void sdbus_set_voltage(SDBus *sdbus, uint16_t millivolts)
80 {
81 SDState *card = get_card(sdbus);
82
83 trace_sdbus_set_voltage(sdbus_name(sdbus), millivolts);
84 if (card) {
85 SDCardClass *sc = SD_CARD_GET_CLASS(card);
86
87 assert(sc->set_voltage);
88 sc->set_voltage(card, millivolts);
89 }
90 }
91
92 int sdbus_do_command(SDBus *sdbus, SDRequest *req, uint8_t *response)
93 {
94 SDState *card = get_card(sdbus);
95
96 trace_sdbus_command(sdbus_name(sdbus), req->cmd, req->arg);
97 if (card) {
98 SDCardClass *sc = SD_CARD_GET_CLASS(card);
99
100 return sc->do_command(card, req, response);
101 }
102
103 return 0;
104 }
105
106 void sdbus_write_byte(SDBus *sdbus, uint8_t value)
107 {
108 SDState *card = get_card(sdbus);
109
110 trace_sdbus_write(sdbus_name(sdbus), value);
111 if (card) {
112 SDCardClass *sc = SD_CARD_GET_CLASS(card);
113
114 sc->write_byte(card, value);
115 }
116 }
117
118 void sdbus_write_data(SDBus *sdbus, const void *buf, size_t length)
119 {
120 SDState *card = get_card(sdbus);
121 const uint8_t *data = buf;
122
123 if (card) {
124 SDCardClass *sc = SD_CARD_GET_CLASS(card);
125
126 for (size_t i = 0; i < length; i++) {
127 trace_sdbus_write(sdbus_name(sdbus), data[i]);
128 sc->write_byte(card, data[i]);
129 }
130 }
131 }
132
133 uint8_t sdbus_read_byte(SDBus *sdbus)
134 {
135 SDState *card = get_card(sdbus);
136 uint8_t value = 0;
137
138 if (card) {
139 SDCardClass *sc = SD_CARD_GET_CLASS(card);
140
141 value = sc->read_byte(card);
142 }
143 trace_sdbus_read(sdbus_name(sdbus), value);
144
145 return value;
146 }
147
148 void sdbus_read_data(SDBus *sdbus, void *buf, size_t length)
149 {
150 SDState *card = get_card(sdbus);
151 uint8_t *data = buf;
152
153 if (card) {
154 SDCardClass *sc = SD_CARD_GET_CLASS(card);
155
156 for (size_t i = 0; i < length; i++) {
157 data[i] = sc->read_byte(card);
158 trace_sdbus_read(sdbus_name(sdbus), data[i]);
159 }
160 }
161 }
162
163 bool sdbus_receive_ready(SDBus *sdbus)
164 {
165 SDState *card = get_card(sdbus);
166
167 if (card) {
168 SDCardClass *sc = SD_CARD_GET_CLASS(card);
169
170 return sc->receive_ready(card);
171 }
172
173 return false;
174 }
175
176 bool sdbus_data_ready(SDBus *sdbus)
177 {
178 SDState *card = get_card(sdbus);
179
180 if (card) {
181 SDCardClass *sc = SD_CARD_GET_CLASS(card);
182
183 return sc->data_ready(card);
184 }
185
186 return false;
187 }
188
189 bool sdbus_get_inserted(SDBus *sdbus)
190 {
191 SDState *card = get_card(sdbus);
192
193 if (card) {
194 SDCardClass *sc = SD_CARD_GET_CLASS(card);
195
196 return sc->get_inserted(card);
197 }
198
199 return false;
200 }
201
202 bool sdbus_get_readonly(SDBus *sdbus)
203 {
204 SDState *card = get_card(sdbus);
205
206 if (card) {
207 SDCardClass *sc = SD_CARD_GET_CLASS(card);
208
209 return sc->get_readonly(card);
210 }
211
212 return false;
213 }
214
215 void sdbus_set_inserted(SDBus *sdbus, bool inserted)
216 {
217 SDBusClass *sbc = SD_BUS_GET_CLASS(sdbus);
218 BusState *qbus = BUS(sdbus);
219
220 if (sbc->set_inserted) {
221 sbc->set_inserted(qbus->parent, inserted);
222 }
223 }
224
225 void sdbus_set_readonly(SDBus *sdbus, bool readonly)
226 {
227 SDBusClass *sbc = SD_BUS_GET_CLASS(sdbus);
228 BusState *qbus = BUS(sdbus);
229
230 if (sbc->set_readonly) {
231 sbc->set_readonly(qbus->parent, readonly);
232 }
233 }
234
235 void sdbus_reparent_card(SDBus *from, SDBus *to)
236 {
237 SDState *card = get_card(from);
238 SDCardClass *sc;
239 bool readonly;
240
241 /* We directly reparent the card object rather than implementing this
242 * as a hotpluggable connection because we don't want to expose SD cards
243 * to users as being hotpluggable, and we can get away with it in this
244 * limited use case. This could perhaps be implemented more cleanly in
245 * future by adding support to the hotplug infrastructure for "device
246 * can be hotplugged only via code, not by user".
247 */
248
249 if (!card) {
250 return;
251 }
252
253 sc = SD_CARD_GET_CLASS(card);
254 readonly = sc->get_readonly(card);
255
256 sdbus_set_inserted(from, false);
257 qdev_set_parent_bus(DEVICE(card), &to->qbus, &error_abort);
258 sdbus_set_inserted(to, true);
259 sdbus_set_readonly(to, readonly);
260 }
261
262 static const TypeInfo sd_bus_info = {
263 .name = TYPE_SD_BUS,
264 .parent = TYPE_BUS,
265 .instance_size = sizeof(SDBus),
266 .class_size = sizeof(SDBusClass),
267 };
268
269 static void sd_bus_register_types(void)
270 {
271 type_register_static(&sd_bus_info);
272 }
273
274 type_init(sd_bus_register_types)