1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include "qemu/osdep.h"
26#include "hw/hw.h"
27#include "sysemu/block-backend.h"
28#include "sysemu/blockdev.h"
29#include "sysemu/dma.h"
30#include "qemu/timer.h"
31#include "qemu/bitops.h"
32#include "qapi/error.h"
33#include "sdhci-internal.h"
34
35
36#ifndef SDHC_DEBUG
37#define SDHC_DEBUG 0
38#endif
39
40#define DPRINT_L1(fmt, args...) \
41 do { \
42 if (SDHC_DEBUG) { \
43 fprintf(stderr, "QEMU SDHC: " fmt, ## args); \
44 } \
45 } while (0)
46#define DPRINT_L2(fmt, args...) \
47 do { \
48 if (SDHC_DEBUG > 1) { \
49 fprintf(stderr, "QEMU SDHC: " fmt, ## args); \
50 } \
51 } while (0)
52#define ERRPRINT(fmt, args...) \
53 do { \
54 if (SDHC_DEBUG) { \
55 fprintf(stderr, "QEMU SDHC ERROR: " fmt, ## args); \
56 } \
57 } while (0)
58
59#define TYPE_SDHCI_BUS "sdhci-bus"
60#define SDHCI_BUS(obj) OBJECT_CHECK(SDBus, (obj), TYPE_SDHCI_BUS)
61
62
63
64
65
66
67#define SDHC_CAPAB_DRIVER_D 1ull
68#define SDHC_CAPAB_DRIVER_C 1ull
69#define SDHC_CAPAB_DRIVER_A 1ull
70#define SDHC_CAPAB_DDR50 1ull
71#define SDHC_CAPAB_SDR104 1ull
72#define SDHC_CAPAB_SDR50 1ull
73#define SDHC_CAPAB_64BITBUS 0ul
74#define SDHC_CAPAB_18V 1ul
75#define SDHC_CAPAB_30V 0ul
76#define SDHC_CAPAB_33V 1ul
77#define SDHC_CAPAB_SUSPRESUME 0ul
78#define SDHC_CAPAB_SDMA 1ul
79#define SDHC_CAPAB_HIGHSPEED 1ul
80#define SDHC_CAPAB_ADMA1 1ul
81#define SDHC_CAPAB_ADMA2 1ul
82
83
84#define SDHC_CAPAB_MAXBLOCKLENGTH 512ul
85
86
87#define SDHC_CAPAB_BASECLKFREQ 52ul
88#define SDHC_CAPAB_TOUNIT 1ul
89
90#define SDHC_CAPAB_TOCLKFREQ 52ul
91
92
93#if SDHC_CAPAB_64BITBUS > 1 || SDHC_CAPAB_18V > 1 || SDHC_CAPAB_30V > 1 || \
94 SDHC_CAPAB_33V > 1 || SDHC_CAPAB_SUSPRESUME > 1 || SDHC_CAPAB_SDMA > 1 || \
95 SDHC_CAPAB_HIGHSPEED > 1 || SDHC_CAPAB_ADMA2 > 1 || SDHC_CAPAB_ADMA1 > 1 ||\
96 SDHC_CAPAB_TOUNIT > 1
97#error Capabilities features can have value 0 or 1 only!
98#endif
99
100#if SDHC_CAPAB_MAXBLOCKLENGTH == 512
101#define MAX_BLOCK_LENGTH 0ul
102#elif SDHC_CAPAB_MAXBLOCKLENGTH == 1024
103#define MAX_BLOCK_LENGTH 1ul
104#elif SDHC_CAPAB_MAXBLOCKLENGTH == 2048
105#define MAX_BLOCK_LENGTH 2ul
106#else
107#error Max host controller block size can have value 512, 1024 or 2048 only!
108#endif
109
110#if (SDHC_CAPAB_BASECLKFREQ > 0 && SDHC_CAPAB_BASECLKFREQ < 10) || \
111 SDHC_CAPAB_BASECLKFREQ > 63
112#error SDclock frequency can have value in range 0, 10-63 only!
113#endif
114
115#if SDHC_CAPAB_TOCLKFREQ > 63
116#error Timeout clock frequency can have value in range 0-63 only!
117#endif
118
119#define SDHC_CAPAB_REG_DEFAULT \
120 ((SDHC_CAPAB_DRIVER_D << 38) | (SDHC_CAPAB_DRIVER_C << 37) |\
121 (SDHC_CAPAB_DRIVER_A << 36) | (SDHC_CAPAB_DDR50 << 34) | \
122 (SDHC_CAPAB_SDR104 << 33) | (SDHC_CAPAB_SDR50 << 32) | \
123 (SDHC_CAPAB_64BITBUS << 28) | (SDHC_CAPAB_18V << 26) | \
124 (SDHC_CAPAB_30V << 25) | (SDHC_CAPAB_33V << 24) | \
125 (SDHC_CAPAB_SUSPRESUME << 23) | (SDHC_CAPAB_SDMA << 22) | \
126 (SDHC_CAPAB_HIGHSPEED << 21) | (SDHC_CAPAB_ADMA1 << 20) | \
127 (SDHC_CAPAB_ADMA2 << 19) | (MAX_BLOCK_LENGTH << 16) | \
128 (SDHC_CAPAB_BASECLKFREQ << 8) | (SDHC_CAPAB_TOUNIT << 7) | \
129 (SDHC_CAPAB_TOCLKFREQ))
130
131#define MASKED_WRITE(reg, mask, val) (reg = (reg & (mask)) | (val))
132
133static uint8_t sdhci_slotint(SDHCIState *s)
134{
135 return (s->norintsts & s->norintsigen) || (s->errintsts & s->errintsigen) ||
136 ((s->norintsts & SDHC_NIS_INSERT) && (s->wakcon & SDHC_WKUP_ON_INS)) ||
137 ((s->norintsts & SDHC_NIS_REMOVE) && (s->wakcon & SDHC_WKUP_ON_RMV));
138}
139
140static inline void sdhci_update_irq(SDHCIState *s)
141{
142 qemu_set_irq(s->irq, sdhci_slotint(s));
143}
144
145static void sdhci_raise_insertion_irq(void *opaque)
146{
147 SDHCIState *s = (SDHCIState *)opaque;
148
149 if (s->norintsts & SDHC_NIS_REMOVE) {
150 timer_mod(s->insert_timer,
151 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + SDHC_INSERTION_DELAY);
152 } else {
153 s->prnsts = 0x1ff0000;
154 if (s->norintstsen & SDHC_NISEN_INSERT) {
155 s->norintsts |= SDHC_NIS_INSERT;
156 }
157 sdhci_update_irq(s);
158 }
159}
160
161static void sdhci_set_inserted(DeviceState *dev, bool level)
162{
163 SDHCIState *s = (SDHCIState *)dev;
164 DPRINT_L1("Card state changed: %s!\n", level ? "insert" : "eject");
165
166 if ((s->norintsts & SDHC_NIS_REMOVE) && level) {
167
168 timer_mod(s->insert_timer,
169 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + SDHC_INSERTION_DELAY);
170 } else {
171 if (level) {
172 s->prnsts = 0x1ff0000;
173 if (s->norintstsen & SDHC_NISEN_INSERT) {
174 s->norintsts |= SDHC_NIS_INSERT;
175 }
176 } else {
177 s->prnsts = 0x1fa0000;
178 s->pwrcon &= ~SDHC_POWER_ON;
179 s->clkcon &= ~SDHC_CLOCK_SDCLK_EN;
180 if (s->norintstsen & SDHC_NISEN_REMOVE) {
181 s->norintsts |= SDHC_NIS_REMOVE;
182 }
183 }
184 sdhci_update_irq(s);
185 }
186}
187
188static void sdhci_set_readonly(DeviceState *dev, bool level)
189{
190 SDHCIState *s = (SDHCIState *)dev;
191
192 if (level) {
193 s->prnsts &= ~SDHC_WRITE_PROTECT;
194 } else {
195
196 s->prnsts |= SDHC_WRITE_PROTECT;
197 }
198}
199
200static void sdhci_reset(SDHCIState *s)
201{
202 DeviceState *dev = DEVICE(s);
203
204 timer_del(s->insert_timer);
205 timer_del(s->transfer_timer);
206
207
208
209 memset(&s->sdmasysad, 0, (uintptr_t)&s->capareg - (uintptr_t)&s->sdmasysad);
210
211
212 sdhci_set_inserted(dev, sdbus_get_inserted(&s->sdbus));
213 sdhci_set_readonly(dev, sdbus_get_readonly(&s->sdbus));
214
215 s->data_count = 0;
216 s->stopped_state = sdhc_not_stopped;
217 s->pending_insert_state = false;
218}
219
220static void sdhci_poweron_reset(DeviceState *dev)
221{
222
223
224
225
226 SDHCIState *s = (SDHCIState *)dev;
227
228 sdhci_reset(s);
229
230 if (s->pending_insert_quirk) {
231 s->pending_insert_state = true;
232 }
233}
234
235static void sdhci_data_transfer(void *opaque);
236
237static void sdhci_send_command(SDHCIState *s)
238{
239 SDRequest request;
240 uint8_t response[16];
241 int rlen;
242
243 s->errintsts = 0;
244 s->acmd12errsts = 0;
245 request.cmd = s->cmdreg >> 8;
246 request.arg = s->argument;
247 DPRINT_L1("sending CMD%u ARG[0x%08x]\n", request.cmd, request.arg);
248 rlen = sdbus_do_command(&s->sdbus, &request, response);
249
250 if (s->cmdreg & SDHC_CMD_RESPONSE) {
251 if (rlen == 4) {
252 s->rspreg[0] = (response[0] << 24) | (response[1] << 16) |
253 (response[2] << 8) | response[3];
254 s->rspreg[1] = s->rspreg[2] = s->rspreg[3] = 0;
255 DPRINT_L1("Response: RSPREG[31..0]=0x%08x\n", s->rspreg[0]);
256 } else if (rlen == 16) {
257 s->rspreg[0] = (response[11] << 24) | (response[12] << 16) |
258 (response[13] << 8) | response[14];
259 s->rspreg[1] = (response[7] << 24) | (response[8] << 16) |
260 (response[9] << 8) | response[10];
261 s->rspreg[2] = (response[3] << 24) | (response[4] << 16) |
262 (response[5] << 8) | response[6];
263 s->rspreg[3] = (response[0] << 16) | (response[1] << 8) |
264 response[2];
265 DPRINT_L1("Response received:\n RSPREG[127..96]=0x%08x, RSPREG[95.."
266 "64]=0x%08x,\n RSPREG[63..32]=0x%08x, RSPREG[31..0]=0x%08x\n",
267 s->rspreg[3], s->rspreg[2], s->rspreg[1], s->rspreg[0]);
268 } else {
269 ERRPRINT("Timeout waiting for command response\n");
270 if (s->errintstsen & SDHC_EISEN_CMDTIMEOUT) {
271 s->errintsts |= SDHC_EIS_CMDTIMEOUT;
272 s->norintsts |= SDHC_NIS_ERR;
273 }
274 }
275
276 if ((s->norintstsen & SDHC_NISEN_TRSCMP) &&
277 (s->cmdreg & SDHC_CMD_RESPONSE) == SDHC_CMD_RSP_WITH_BUSY) {
278 s->norintsts |= SDHC_NIS_TRSCMP;
279 }
280 }
281
282 if (s->norintstsen & SDHC_NISEN_CMDCMP) {
283 s->norintsts |= SDHC_NIS_CMDCMP;
284 }
285
286 sdhci_update_irq(s);
287
288 if (s->blksize && (s->cmdreg & SDHC_CMD_DATA_PRESENT)) {
289 s->data_count = 0;
290 sdhci_data_transfer(s);
291 }
292}
293
294static void sdhci_end_transfer(SDHCIState *s)
295{
296
297 if ((s->trnmod & SDHC_TRNS_ACMD12) != 0) {
298 SDRequest request;
299 uint8_t response[16];
300
301 request.cmd = 0x0C;
302 request.arg = 0;
303 DPRINT_L1("Automatically issue CMD%d %08x\n", request.cmd, request.arg);
304 sdbus_do_command(&s->sdbus, &request, response);
305
306 s->rspreg[3] = (response[0] << 24) | (response[1] << 16) |
307 (response[2] << 8) | response[3];
308 }
309
310 s->prnsts &= ~(SDHC_DOING_READ | SDHC_DOING_WRITE |
311 SDHC_DAT_LINE_ACTIVE | SDHC_DATA_INHIBIT |
312 SDHC_SPACE_AVAILABLE | SDHC_DATA_AVAILABLE);
313
314 if (s->norintstsen & SDHC_NISEN_TRSCMP) {
315 s->norintsts |= SDHC_NIS_TRSCMP;
316 }
317
318 sdhci_update_irq(s);
319}
320
321
322
323
324
325
326static void sdhci_read_block_from_card(SDHCIState *s)
327{
328 int index = 0;
329
330 if ((s->trnmod & SDHC_TRNS_MULTI) &&
331 (s->trnmod & SDHC_TRNS_BLK_CNT_EN) && (s->blkcnt == 0)) {
332 return;
333 }
334
335 for (index = 0; index < (s->blksize & 0x0fff); index++) {
336 s->fifo_buffer[index] = sdbus_read_data(&s->sdbus);
337 }
338
339
340 s->prnsts |= SDHC_DATA_AVAILABLE;
341 if (s->norintstsen & SDHC_NISEN_RBUFRDY) {
342 s->norintsts |= SDHC_NIS_RBUFRDY;
343 }
344
345
346 if ((s->trnmod & SDHC_TRNS_MULTI) == 0 ||
347 ((s->trnmod & SDHC_TRNS_MULTI) && s->blkcnt == 1)) {
348 s->prnsts &= ~SDHC_DAT_LINE_ACTIVE;
349 }
350
351
352
353 if (s->stopped_state == sdhc_gap_read && (s->trnmod & SDHC_TRNS_MULTI) &&
354 s->blkcnt != 1) {
355 s->prnsts &= ~SDHC_DAT_LINE_ACTIVE;
356 if (s->norintstsen & SDHC_EISEN_BLKGAP) {
357 s->norintsts |= SDHC_EIS_BLKGAP;
358 }
359 }
360
361 sdhci_update_irq(s);
362}
363
364
365static uint32_t sdhci_read_dataport(SDHCIState *s, unsigned size)
366{
367 uint32_t value = 0;
368 int i;
369
370
371 if ((s->prnsts & SDHC_DATA_AVAILABLE) == 0) {
372 ERRPRINT("Trying to read from empty buffer\n");
373 return 0;
374 }
375
376 for (i = 0; i < size; i++) {
377 value |= s->fifo_buffer[s->data_count] << i * 8;
378 s->data_count++;
379
380 if ((s->data_count) >= (s->blksize & 0x0fff)) {
381 DPRINT_L2("All %u bytes of data have been read from input buffer\n",
382 s->data_count);
383 s->prnsts &= ~SDHC_DATA_AVAILABLE;
384 s->data_count = 0;
385
386 if (s->trnmod & SDHC_TRNS_BLK_CNT_EN) {
387 s->blkcnt--;
388 }
389
390
391 if ((s->trnmod & SDHC_TRNS_MULTI) == 0 ||
392 ((s->trnmod & SDHC_TRNS_BLK_CNT_EN) && (s->blkcnt == 0)) ||
393
394 (s->stopped_state == sdhc_gap_read &&
395 !(s->prnsts & SDHC_DAT_LINE_ACTIVE))) {
396 sdhci_end_transfer(s);
397 } else {
398 sdhci_read_block_from_card(s);
399 }
400 break;
401 }
402 }
403
404 return value;
405}
406
407
408static void sdhci_write_block_to_card(SDHCIState *s)
409{
410 int index = 0;
411
412 if (s->prnsts & SDHC_SPACE_AVAILABLE) {
413 if (s->norintstsen & SDHC_NISEN_WBUFRDY) {
414 s->norintsts |= SDHC_NIS_WBUFRDY;
415 }
416 sdhci_update_irq(s);
417 return;
418 }
419
420 if (s->trnmod & SDHC_TRNS_BLK_CNT_EN) {
421 if (s->blkcnt == 0) {
422 return;
423 } else {
424 s->blkcnt--;
425 }
426 }
427
428 for (index = 0; index < (s->blksize & 0x0fff); index++) {
429 sdbus_write_data(&s->sdbus, s->fifo_buffer[index]);
430 }
431
432
433 s->prnsts |= SDHC_SPACE_AVAILABLE;
434
435
436 if ((s->trnmod & SDHC_TRNS_MULTI) == 0 ||
437 ((s->trnmod & SDHC_TRNS_MULTI) &&
438 (s->trnmod & SDHC_TRNS_BLK_CNT_EN) && (s->blkcnt == 0))) {
439 sdhci_end_transfer(s);
440 } else if (s->norintstsen & SDHC_NISEN_WBUFRDY) {
441 s->norintsts |= SDHC_NIS_WBUFRDY;
442 }
443
444
445 if (s->stopped_state == sdhc_gap_write && (s->trnmod & SDHC_TRNS_MULTI) &&
446 s->blkcnt > 0) {
447 s->prnsts &= ~SDHC_DOING_WRITE;
448 if (s->norintstsen & SDHC_EISEN_BLKGAP) {
449 s->norintsts |= SDHC_EIS_BLKGAP;
450 }
451 sdhci_end_transfer(s);
452 }
453
454 sdhci_update_irq(s);
455}
456
457
458
459static void sdhci_write_dataport(SDHCIState *s, uint32_t value, unsigned size)
460{
461 unsigned i;
462
463
464 if (!(s->prnsts & SDHC_SPACE_AVAILABLE)) {
465 ERRPRINT("Can't write to data buffer: buffer full\n");
466 return;
467 }
468
469 for (i = 0; i < size; i++) {
470 s->fifo_buffer[s->data_count] = value & 0xFF;
471 s->data_count++;
472 value >>= 8;
473 if (s->data_count >= (s->blksize & 0x0fff)) {
474 DPRINT_L2("write buffer filled with %u bytes of data\n",
475 s->data_count);
476 s->data_count = 0;
477 s->prnsts &= ~SDHC_SPACE_AVAILABLE;
478 if (s->prnsts & SDHC_DOING_WRITE) {
479 sdhci_write_block_to_card(s);
480 }
481 }
482 }
483}
484
485
486
487
488
489
490static void sdhci_sdma_transfer_multi_blocks(SDHCIState *s)
491{
492 bool page_aligned = false;
493 unsigned int n, begin;
494 const uint16_t block_size = s->blksize & 0x0fff;
495 uint32_t boundary_chk = 1 << (((s->blksize & 0xf000) >> 12) + 12);
496 uint32_t boundary_count = boundary_chk - (s->sdmasysad % boundary_chk);
497
498
499
500
501 if ((s->sdmasysad % boundary_chk) == 0) {
502 page_aligned = true;
503 }
504
505 if (s->trnmod & SDHC_TRNS_READ) {
506 s->prnsts |= SDHC_DOING_READ | SDHC_DATA_INHIBIT |
507 SDHC_DAT_LINE_ACTIVE;
508 while (s->blkcnt) {
509 if (s->data_count == 0) {
510 for (n = 0; n < block_size; n++) {
511 s->fifo_buffer[n] = sdbus_read_data(&s->sdbus);
512 }
513 }
514 begin = s->data_count;
515 if (((boundary_count + begin) < block_size) && page_aligned) {
516 s->data_count = boundary_count + begin;
517 boundary_count = 0;
518 } else {
519 s->data_count = block_size;
520 boundary_count -= block_size - begin;
521 if (s->trnmod & SDHC_TRNS_BLK_CNT_EN) {
522 s->blkcnt--;
523 }
524 }
525 dma_memory_write(s->dma_as, s->sdmasysad,
526 &s->fifo_buffer[begin], s->data_count - begin);
527 s->sdmasysad += s->data_count - begin;
528 if (s->data_count == block_size) {
529 s->data_count = 0;
530 }
531 if (page_aligned && boundary_count == 0) {
532 break;
533 }
534 }
535 } else {
536 s->prnsts |= SDHC_DOING_WRITE | SDHC_DATA_INHIBIT |
537 SDHC_DAT_LINE_ACTIVE;
538 while (s->blkcnt) {
539 begin = s->data_count;
540 if (((boundary_count + begin) < block_size) && page_aligned) {
541 s->data_count = boundary_count + begin;
542 boundary_count = 0;
543 } else {
544 s->data_count = block_size;
545 boundary_count -= block_size - begin;
546 }
547 dma_memory_read(s->dma_as, s->sdmasysad,
548 &s->fifo_buffer[begin], s->data_count);
549 s->sdmasysad += s->data_count - begin;
550 if (s->data_count == block_size) {
551 for (n = 0; n < block_size; n++) {
552 sdbus_write_data(&s->sdbus, s->fifo_buffer[n]);
553 }
554 s->data_count = 0;
555 if (s->trnmod & SDHC_TRNS_BLK_CNT_EN) {
556 s->blkcnt--;
557 }
558 }
559 if (page_aligned && boundary_count == 0) {
560 break;
561 }
562 }
563 }
564
565 if (s->blkcnt == 0) {
566 sdhci_end_transfer(s);
567 } else {
568 if (s->norintstsen & SDHC_NISEN_DMA) {
569 s->norintsts |= SDHC_NIS_DMA;
570 }
571 sdhci_update_irq(s);
572 }
573}
574
575
576
577static void sdhci_sdma_transfer_single_block(SDHCIState *s)
578{
579 int n;
580 uint32_t datacnt = s->blksize & 0x0fff;
581
582 if (s->trnmod & SDHC_TRNS_READ) {
583 for (n = 0; n < datacnt; n++) {
584 s->fifo_buffer[n] = sdbus_read_data(&s->sdbus);
585 }
586 dma_memory_write(s->dma_as, s->sdmasysad, s->fifo_buffer, datacnt);
587 } else {
588 dma_memory_read(s->dma_as, s->sdmasysad, s->fifo_buffer, datacnt);
589 for (n = 0; n < datacnt; n++) {
590 sdbus_write_data(&s->sdbus, s->fifo_buffer[n]);
591 }
592 }
593
594 if (s->trnmod & SDHC_TRNS_BLK_CNT_EN) {
595 s->blkcnt--;
596 }
597
598 sdhci_end_transfer(s);
599}
600
601typedef struct ADMADescr {
602 hwaddr addr;
603 uint16_t length;
604 uint8_t attr;
605 uint8_t incr;
606} ADMADescr;
607
608static void get_adma_description(SDHCIState *s, ADMADescr *dscr)
609{
610 uint32_t adma1 = 0;
611 uint64_t adma2 = 0;
612 hwaddr entry_addr = (hwaddr)s->admasysaddr;
613 switch (SDHC_DMA_TYPE(s->hostctl)) {
614 case SDHC_CTRL_ADMA2_32:
615 dma_memory_read(s->dma_as, entry_addr, (uint8_t *)&adma2,
616 sizeof(adma2));
617 adma2 = le64_to_cpu(adma2);
618
619
620
621 dscr->addr = (hwaddr)extract64(adma2, 32, 32) & ~0x3ull;
622 dscr->length = (uint16_t)extract64(adma2, 16, 16);
623 dscr->attr = (uint8_t)extract64(adma2, 0, 7);
624 dscr->incr = 8;
625 break;
626 case SDHC_CTRL_ADMA1_32:
627 dma_memory_read(s->dma_as, entry_addr, (uint8_t *)&adma1,
628 sizeof(adma1));
629 adma1 = le32_to_cpu(adma1);
630 dscr->addr = (hwaddr)(adma1 & 0xFFFFF000);
631 dscr->attr = (uint8_t)extract32(adma1, 0, 7);
632 dscr->incr = 4;
633 if ((dscr->attr & SDHC_ADMA_ATTR_ACT_MASK) == SDHC_ADMA_ATTR_SET_LEN) {
634 dscr->length = (uint16_t)extract32(adma1, 12, 16);
635 } else {
636 dscr->length = 4096;
637 }
638 break;
639 case SDHC_CTRL_ADMA2_64:
640 dma_memory_read(s->dma_as, entry_addr, (uint8_t *)(&dscr->attr), 1);
641 dma_memory_read(s->dma_as, entry_addr + 2,
642 (uint8_t *)(&dscr->length), 2);
643 dscr->length = le16_to_cpu(dscr->length);
644 dma_memory_read(s->dma_as, entry_addr + 4,
645 (uint8_t *)(&dscr->addr), 8);
646 dscr->attr = le64_to_cpu(dscr->attr);
647 dscr->attr &= 0xfffffff8;
648 dscr->incr = 12;
649 break;
650 }
651}
652
653
654
655static void sdhci_do_adma(SDHCIState *s)
656{
657 unsigned int n, begin, length;
658 const uint16_t block_size = s->blksize & 0x0fff;
659 ADMADescr dscr;
660 int i;
661
662 for (i = 0; i < SDHC_ADMA_DESCS_PER_DELAY; ++i) {
663 s->admaerr &= ~SDHC_ADMAERR_LENGTH_MISMATCH;
664
665 get_adma_description(s, &dscr);
666 DPRINT_L2("ADMA loop: addr=" TARGET_FMT_plx ", len=%d, attr=%x\n",
667 dscr.addr, dscr.length, dscr.attr);
668
669 if ((dscr.attr & SDHC_ADMA_ATTR_VALID) == 0) {
670
671 s->admaerr &= ~SDHC_ADMAERR_STATE_MASK;
672 s->admaerr |= SDHC_ADMAERR_STATE_ST_FDS;
673
674
675 if (s->errintstsen & SDHC_EISEN_ADMAERR) {
676 s->errintsts |= SDHC_EIS_ADMAERR;
677 s->norintsts |= SDHC_NIS_ERR;
678 }
679
680 sdhci_update_irq(s);
681 return;
682 }
683
684 length = dscr.length ? dscr.length : 65536;
685
686 switch (dscr.attr & SDHC_ADMA_ATTR_ACT_MASK) {
687 case SDHC_ADMA_ATTR_ACT_TRAN:
688
689 if (s->trnmod & SDHC_TRNS_READ) {
690 while (length) {
691 if (s->data_count == 0) {
692 for (n = 0; n < block_size; n++) {
693 s->fifo_buffer[n] = sdbus_read_data(&s->sdbus);
694 }
695 }
696 begin = s->data_count;
697 if ((length + begin) < block_size) {
698 s->data_count = length + begin;
699 length = 0;
700 } else {
701 s->data_count = block_size;
702 length -= block_size - begin;
703 }
704 dma_memory_write(s->dma_as, dscr.addr,
705 &s->fifo_buffer[begin],
706 s->data_count - begin);
707 dscr.addr += s->data_count - begin;
708 if (s->data_count == block_size) {
709 s->data_count = 0;
710 if (s->trnmod & SDHC_TRNS_BLK_CNT_EN) {
711 s->blkcnt--;
712 if (s->blkcnt == 0) {
713 break;
714 }
715 }
716 }
717 }
718 } else {
719 while (length) {
720 begin = s->data_count;
721 if ((length + begin) < block_size) {
722 s->data_count = length + begin;
723 length = 0;
724 } else {
725 s->data_count = block_size;
726 length -= block_size - begin;
727 }
728 dma_memory_read(s->dma_as, dscr.addr,
729 &s->fifo_buffer[begin],
730 s->data_count - begin);
731 dscr.addr += s->data_count - begin;
732 if (s->data_count == block_size) {
733 for (n = 0; n < block_size; n++) {
734 sdbus_write_data(&s->sdbus, s->fifo_buffer[n]);
735 }
736 s->data_count = 0;
737 if (s->trnmod & SDHC_TRNS_BLK_CNT_EN) {
738 s->blkcnt--;
739 if (s->blkcnt == 0) {
740 break;
741 }
742 }
743 }
744 }
745 }
746 s->admasysaddr += dscr.incr;
747 break;
748 case SDHC_ADMA_ATTR_ACT_LINK:
749 s->admasysaddr = dscr.addr;
750 DPRINT_L1("ADMA link: admasysaddr=0x%" PRIx64 "\n",
751 s->admasysaddr);
752 break;
753 default:
754 s->admasysaddr += dscr.incr;
755 break;
756 }
757
758 if (dscr.attr & SDHC_ADMA_ATTR_INT) {
759 DPRINT_L1("ADMA interrupt: admasysaddr=0x%" PRIx64 "\n",
760 s->admasysaddr);
761 if (s->norintstsen & SDHC_NISEN_DMA) {
762 s->norintsts |= SDHC_NIS_DMA;
763 }
764
765 sdhci_update_irq(s);
766 }
767
768
769 if (((s->trnmod & SDHC_TRNS_BLK_CNT_EN) &&
770 (s->blkcnt == 0)) || (dscr.attr & SDHC_ADMA_ATTR_END)) {
771 DPRINT_L2("ADMA transfer completed\n");
772 if (length || ((dscr.attr & SDHC_ADMA_ATTR_END) &&
773 (s->trnmod & SDHC_TRNS_BLK_CNT_EN) &&
774 s->blkcnt != 0)) {
775 ERRPRINT("SD/MMC host ADMA length mismatch\n");
776 s->admaerr |= SDHC_ADMAERR_LENGTH_MISMATCH |
777 SDHC_ADMAERR_STATE_ST_TFR;
778 if (s->errintstsen & SDHC_EISEN_ADMAERR) {
779 ERRPRINT("Set ADMA error flag\n");
780 s->errintsts |= SDHC_EIS_ADMAERR;
781 s->norintsts |= SDHC_NIS_ERR;
782 }
783
784 sdhci_update_irq(s);
785 }
786 sdhci_end_transfer(s);
787 return;
788 }
789
790 }
791
792
793 timer_mod(s->transfer_timer,
794 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + SDHC_TRANSFER_DELAY / 16);
795}
796
797
798
799static void sdhci_data_transfer(void *opaque)
800{
801 SDHCIState *s = (SDHCIState *)opaque;
802
803 if (s->trnmod & SDHC_TRNS_DMA) {
804 switch (SDHC_DMA_TYPE(s->hostctl)) {
805 case SDHC_CTRL_SDMA:
806 if ((s->trnmod & SDHC_TRNS_MULTI) &&
807 (!(s->trnmod & SDHC_TRNS_BLK_CNT_EN) || s->blkcnt == 0)) {
808 break;
809 }
810
811 if ((s->blkcnt == 1) || !(s->trnmod & SDHC_TRNS_MULTI)) {
812 sdhci_sdma_transfer_single_block(s);
813 } else {
814 sdhci_sdma_transfer_multi_blocks(s);
815 }
816
817 break;
818 case SDHC_CTRL_ADMA1_32:
819 if (!(s->capareg & SDHC_CAN_DO_ADMA1)) {
820 ERRPRINT("ADMA1 not supported\n");
821 break;
822 }
823
824 sdhci_do_adma(s);
825 break;
826 case SDHC_CTRL_ADMA2_32:
827 if (!(s->capareg & SDHC_CAN_DO_ADMA2)) {
828 ERRPRINT("ADMA2 not supported\n");
829 break;
830 }
831
832 sdhci_do_adma(s);
833 break;
834 case SDHC_CTRL_ADMA2_64:
835 if (!(s->capareg & SDHC_CAN_DO_ADMA2) ||
836 !(s->capareg & SDHC_64_BIT_BUS_SUPPORT)) {
837 ERRPRINT("64 bit ADMA not supported\n");
838 break;
839 }
840
841 sdhci_do_adma(s);
842 break;
843 default:
844 ERRPRINT("Unsupported DMA type\n");
845 break;
846 }
847 } else {
848 if ((s->trnmod & SDHC_TRNS_READ) && sdbus_data_ready(&s->sdbus)) {
849 s->prnsts |= SDHC_DOING_READ | SDHC_DATA_INHIBIT |
850 SDHC_DAT_LINE_ACTIVE;
851 sdhci_read_block_from_card(s);
852 } else {
853 s->prnsts |= SDHC_DOING_WRITE | SDHC_DAT_LINE_ACTIVE |
854 SDHC_SPACE_AVAILABLE | SDHC_DATA_INHIBIT;
855 sdhci_write_block_to_card(s);
856 }
857 }
858}
859
860static bool sdhci_can_issue_command(SDHCIState *s)
861{
862 if (!SDHC_CLOCK_IS_ON(s->clkcon) ||
863 (((s->prnsts & SDHC_DATA_INHIBIT) || s->stopped_state) &&
864 ((s->cmdreg & SDHC_CMD_DATA_PRESENT) ||
865 ((s->cmdreg & SDHC_CMD_RESPONSE) == SDHC_CMD_RSP_WITH_BUSY &&
866 !(SDHC_COMMAND_TYPE(s->cmdreg) == SDHC_CMD_ABORT))))) {
867 return false;
868 }
869
870 return true;
871}
872
873
874
875static inline bool
876sdhci_buff_access_is_sequential(SDHCIState *s, unsigned byte_num)
877{
878 if ((s->data_count & 0x3) != byte_num) {
879 ERRPRINT("Non-sequential access to Buffer Data Port register"
880 "is prohibited\n");
881 return false;
882 }
883 return true;
884}
885
886static uint64_t sdhci_read(void *opaque, hwaddr offset, unsigned size)
887{
888 SDHCIState *s = (SDHCIState *)opaque;
889 uint32_t ret = 0;
890
891 switch (offset & ~0x3) {
892 case SDHC_SYSAD:
893 ret = s->sdmasysad;
894 break;
895 case SDHC_BLKSIZE:
896 ret = s->blksize | (s->blkcnt << 16);
897 break;
898 case SDHC_ARGUMENT:
899 ret = s->argument;
900 break;
901 case SDHC_TRNMOD:
902 ret = s->trnmod | (s->cmdreg << 16);
903 break;
904 case SDHC_RSPREG0 ... SDHC_RSPREG3:
905 ret = s->rspreg[((offset & ~0x3) - SDHC_RSPREG0) >> 2];
906 break;
907 case SDHC_BDATA:
908 if (sdhci_buff_access_is_sequential(s, offset - SDHC_BDATA)) {
909 ret = sdhci_read_dataport(s, size);
910 DPRINT_L2("read %ub: addr[0x%04x] -> %u(0x%x)\n", size, (int)offset,
911 ret, ret);
912 return ret;
913 }
914 break;
915 case SDHC_PRNSTS:
916 ret = s->prnsts;
917 ret = deposit32(ret, SDHC_DAT_LVL_SHIFT, SDHC_DAT_LVL_LENGTH,
918 sdbus_get_dat_lines(&s->sdbus));
919 ret = deposit32(ret, SDHC_CMD_LVL_SHIFT, 1, sdbus_get_cmd_line(&s->sdbus));
920
921 break;
922 case SDHC_HOSTCTL:
923 ret = s->hostctl | (s->pwrcon << 8) | (s->blkgap << 16) |
924 (s->wakcon << 24);
925 break;
926 case SDHC_CLKCON:
927 ret = s->clkcon | (s->timeoutcon << 16);
928 break;
929 case SDHC_NORINTSTS:
930 ret = s->norintsts | (s->errintsts << 16);
931 break;
932 case SDHC_NORINTSTSEN:
933 ret = s->norintstsen | (s->errintstsen << 16);
934 break;
935 case SDHC_NORINTSIGEN:
936 ret = s->norintsigen | (s->errintsigen << 16);
937 break;
938 case SDHC_ACMD12ERRSTS:
939 ret = s->acmd12errsts | (s->hostctl2 << 16);
940 break;
941 case SDHC_CAPAREG_HI:
942 ret = extract64(s->capareg, 32, 32);
943 break;
944 case SDHC_CAPAREG:
945 ret = extract64(s->capareg, 0, 32);
946 break;
947 case SDHC_MAXCURR:
948 ret = s->maxcurr;
949 break;
950 case SDHC_ADMAERR:
951 ret = s->admaerr;
952 break;
953 case SDHC_ADMASYSADDR:
954 ret = (uint32_t)s->admasysaddr;
955 break;
956 case SDHC_ADMASYSADDR + 4:
957 ret = (uint32_t)(s->admasysaddr >> 32);
958 break;
959 case SDHC_SLOT_INT_STATUS:
960 ret = (SD_HOST_SPECv2_VERS << 16) | sdhci_slotint(s);
961 break;
962 default:
963 ERRPRINT("bad %ub read: addr[0x%04x]\n", size, (int)offset);
964 break;
965 }
966
967 ret >>= (offset & 0x3) * 8;
968 ret &= (1ULL << (size * 8)) - 1;
969 DPRINT_L2("read %ub: addr[0x%04x] -> %u(0x%x)\n", size, (int)offset, ret, ret);
970 return ret;
971}
972
973static inline void sdhci_blkgap_write(SDHCIState *s, uint8_t value)
974{
975 if ((value & SDHC_STOP_AT_GAP_REQ) && (s->blkgap & SDHC_STOP_AT_GAP_REQ)) {
976 return;
977 }
978 s->blkgap = value & SDHC_STOP_AT_GAP_REQ;
979
980 if ((value & SDHC_CONTINUE_REQ) && s->stopped_state &&
981 (s->blkgap & SDHC_STOP_AT_GAP_REQ) == 0) {
982 if (s->stopped_state == sdhc_gap_read) {
983 s->prnsts |= SDHC_DAT_LINE_ACTIVE | SDHC_DOING_READ;
984 sdhci_read_block_from_card(s);
985 } else {
986 s->prnsts |= SDHC_DAT_LINE_ACTIVE | SDHC_DOING_WRITE;
987 sdhci_write_block_to_card(s);
988 }
989 s->stopped_state = sdhc_not_stopped;
990 } else if (!s->stopped_state && (value & SDHC_STOP_AT_GAP_REQ)) {
991 if (s->prnsts & SDHC_DOING_READ) {
992 s->stopped_state = sdhc_gap_read;
993 } else if (s->prnsts & SDHC_DOING_WRITE) {
994 s->stopped_state = sdhc_gap_write;
995 }
996 }
997}
998
999static inline void sdhci_reset_write(SDHCIState *s, uint8_t value)
1000{
1001 switch (value) {
1002 case SDHC_RESET_ALL:
1003 sdhci_reset(s);
1004 break;
1005 case SDHC_RESET_CMD:
1006 s->prnsts &= ~SDHC_CMD_INHIBIT;
1007 s->norintsts &= ~SDHC_NIS_CMDCMP;
1008 break;
1009 case SDHC_RESET_DATA:
1010 s->data_count = 0;
1011 s->prnsts &= ~(SDHC_SPACE_AVAILABLE | SDHC_DATA_AVAILABLE |
1012 SDHC_DOING_READ | SDHC_DOING_WRITE |
1013 SDHC_DATA_INHIBIT | SDHC_DAT_LINE_ACTIVE);
1014 s->blkgap &= ~(SDHC_STOP_AT_GAP_REQ | SDHC_CONTINUE_REQ);
1015 s->stopped_state = sdhc_not_stopped;
1016 s->norintsts &= ~(SDHC_NIS_WBUFRDY | SDHC_NIS_RBUFRDY |
1017 SDHC_NIS_DMA | SDHC_NIS_TRSCMP | SDHC_NIS_BLKGAP);
1018 break;
1019 }
1020}
1021
1022static void
1023sdhci_write(void *opaque, hwaddr offset, uint64_t val, unsigned size)
1024{
1025 SDHCIState *s = (SDHCIState *)opaque;
1026 unsigned shift = 8 * (offset & 0x3);
1027 uint32_t mask = ~(((1ULL << (size * 8)) - 1) << shift);
1028 uint32_t value = val;
1029 value <<= shift;
1030
1031 switch (offset & ~0x3) {
1032 case SDHC_SYSAD:
1033 s->sdmasysad = (s->sdmasysad & mask) | value;
1034 MASKED_WRITE(s->sdmasysad, mask, value);
1035
1036 if (!(mask & 0xFF000000) && TRANSFERRING_DATA(s->prnsts) && s->blkcnt &&
1037 s->blksize && SDHC_DMA_TYPE(s->hostctl) == SDHC_CTRL_SDMA) {
1038 sdhci_sdma_transfer_multi_blocks(s);
1039 }
1040 break;
1041 case SDHC_BLKSIZE:
1042 if (!TRANSFERRING_DATA(s->prnsts)) {
1043 MASKED_WRITE(s->blksize, mask, value);
1044 MASKED_WRITE(s->blkcnt, mask >> 16, value >> 16);
1045 }
1046
1047
1048 if (extract32(s->blksize, 0, 12) > s->buf_maxsz) {
1049 qemu_log_mask(LOG_GUEST_ERROR, "%s: Size 0x%x is larger than " \
1050 "the maximum buffer 0x%x", __func__, s->blksize,
1051 s->buf_maxsz);
1052
1053 s->blksize = deposit32(s->blksize, 0, 12, s->buf_maxsz);
1054 }
1055
1056 break;
1057 case SDHC_ARGUMENT:
1058 MASKED_WRITE(s->argument, mask, value);
1059 break;
1060 case SDHC_TRNMOD:
1061
1062
1063 if (!(s->capareg & SDHC_CAN_DO_DMA)) {
1064 value &= ~SDHC_TRNS_DMA;
1065 }
1066 MASKED_WRITE(s->trnmod, mask, value);
1067 MASKED_WRITE(s->cmdreg, mask >> 16, value >> 16);
1068
1069
1070 if ((mask & 0xFF000000) || !sdhci_can_issue_command(s)) {
1071 break;
1072 }
1073
1074 sdhci_send_command(s);
1075 break;
1076 case SDHC_BDATA:
1077 if (sdhci_buff_access_is_sequential(s, offset - SDHC_BDATA)) {
1078 sdhci_write_dataport(s, value >> shift, size);
1079 }
1080 break;
1081 case SDHC_HOSTCTL:
1082 if (!(mask & 0xFF0000)) {
1083 sdhci_blkgap_write(s, value >> 16);
1084 }
1085 MASKED_WRITE(s->hostctl, mask, value);
1086 MASKED_WRITE(s->pwrcon, mask >> 8, value >> 8);
1087 MASKED_WRITE(s->wakcon, mask >> 24, value >> 24);
1088 break;
1089 case SDHC_ACMD12ERRSTS:
1090
1091 if (value & SDHC_CTRL2_EXECUTE_TUNING) {
1092
1093 value &= ~SDHC_CTRL2_EXECUTE_TUNING;
1094 value |= SDHC_CTRL2_SAMPLING_CLKSEL;
1095 }
1096 s->acmd12errsts = value;
1097 MASKED_WRITE(s->hostctl2, mask >> 16, value >> 16);
1098 sdbus_set_voltage(&s->sdbus, s->hostctl2 & SDHC_CTRL2_VOLTAGE_SWITCH ?
1099 SD_VOLTAGE_18 : SD_VOLTAGE_33);
1100 break;
1101 case SDHC_CLKCON:
1102 if (!(mask & 0xFF000000)) {
1103 sdhci_reset_write(s, value >> 24);
1104 }
1105 MASKED_WRITE(s->clkcon, mask, value);
1106 MASKED_WRITE(s->timeoutcon, mask >> 16, value >> 16);
1107 if (s->clkcon & SDHC_CLOCK_INT_EN) {
1108 s->clkcon |= SDHC_CLOCK_INT_STABLE;
1109 } else {
1110 s->clkcon &= ~SDHC_CLOCK_INT_STABLE;
1111 }
1112 break;
1113 case SDHC_NORINTSTS:
1114 if (s->norintstsen & SDHC_NISEN_CARDINT) {
1115 value &= ~SDHC_NIS_CARDINT;
1116 }
1117 s->norintsts &= mask | ~value;
1118 s->errintsts &= (mask >> 16) | ~(value >> 16);
1119 if (s->errintsts) {
1120 s->norintsts |= SDHC_NIS_ERR;
1121 } else {
1122 s->norintsts &= ~SDHC_NIS_ERR;
1123 }
1124 sdhci_update_irq(s);
1125 break;
1126 case SDHC_NORINTSTSEN:
1127 MASKED_WRITE(s->norintstsen, mask, value);
1128 MASKED_WRITE(s->errintstsen, mask >> 16, value >> 16);
1129 s->norintsts &= s->norintstsen;
1130 s->errintsts &= s->errintstsen;
1131 if (s->errintsts) {
1132 s->norintsts |= SDHC_NIS_ERR;
1133 } else {
1134 s->norintsts &= ~SDHC_NIS_ERR;
1135 }
1136
1137
1138 if ((s->norintstsen & SDHC_NISEN_INSERT) && s->pending_insert_state) {
1139 assert(s->pending_insert_quirk);
1140 s->norintsts |= SDHC_NIS_INSERT;
1141 s->pending_insert_state = false;
1142 }
1143 sdhci_update_irq(s);
1144 break;
1145 case SDHC_NORINTSIGEN:
1146 MASKED_WRITE(s->norintsigen, mask, value);
1147 MASKED_WRITE(s->errintsigen, mask >> 16, value >> 16);
1148 sdhci_update_irq(s);
1149 break;
1150 case SDHC_ADMAERR:
1151 MASKED_WRITE(s->admaerr, mask, value);
1152 break;
1153 case SDHC_ADMASYSADDR:
1154 s->admasysaddr = (s->admasysaddr & (0xFFFFFFFF00000000ULL |
1155 (uint64_t)mask)) | (uint64_t)value;
1156 break;
1157 case SDHC_ADMASYSADDR + 4:
1158 s->admasysaddr = (s->admasysaddr & (0x00000000FFFFFFFFULL |
1159 ((uint64_t)mask << 32))) | ((uint64_t)value << 32);
1160 break;
1161 case SDHC_FEAER:
1162 s->acmd12errsts |= value;
1163 s->errintsts |= (value >> 16) & s->errintstsen;
1164 if (s->acmd12errsts) {
1165 s->errintsts |= SDHC_EIS_CMD12ERR;
1166 }
1167 if (s->errintsts) {
1168 s->norintsts |= SDHC_NIS_ERR;
1169 }
1170 sdhci_update_irq(s);
1171 break;
1172 default:
1173 ERRPRINT("bad %ub write offset: addr[0x%04x] <- %u(0x%x)\n",
1174 size, (int)offset, value >> shift, value >> shift);
1175 break;
1176 }
1177 DPRINT_L2("write %ub: addr[0x%04x] <- %u(0x%x)\n",
1178 size, (int)offset, value >> shift, value >> shift);
1179}
1180
1181static const MemoryRegionOps sdhci_mmio_ops = {
1182 .read = sdhci_read,
1183 .write = sdhci_write,
1184 .valid = {
1185 .min_access_size = 1,
1186 .max_access_size = 4,
1187 .unaligned = false
1188 },
1189 .endianness = DEVICE_LITTLE_ENDIAN,
1190};
1191
1192static inline unsigned int sdhci_get_fifolen(SDHCIState *s)
1193{
1194 switch (SDHC_CAPAB_BLOCKSIZE(s->capareg)) {
1195 case 0:
1196 return 512;
1197 case 1:
1198 return 1024;
1199 case 2:
1200 return 2048;
1201 default:
1202 hw_error("SDHC: unsupported value for maximum block size\n");
1203 return 0;
1204 }
1205}
1206
1207static void sdhci_initfn(SDHCIState *s)
1208{
1209 qbus_create_inplace(&s->sdbus, sizeof(s->sdbus),
1210 TYPE_SDHCI_BUS, DEVICE(s), "sd-bus");
1211
1212 s->insert_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, sdhci_raise_insertion_irq, s);
1213 s->transfer_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, sdhci_data_transfer, s);
1214
1215 object_property_add_link(OBJECT(s), "dma", TYPE_MEMORY_REGION,
1216 (Object **)&s->dma_mr,
1217 qdev_prop_allow_set_link_before_realize,
1218 OBJ_PROP_LINK_UNREF_ON_RELEASE,
1219 &error_abort);
1220}
1221
1222static void sdhci_uninitfn(SDHCIState *s)
1223{
1224 timer_del(s->insert_timer);
1225 timer_free(s->insert_timer);
1226 timer_del(s->transfer_timer);
1227 timer_free(s->transfer_timer);
1228 qemu_free_irq(s->eject_cb);
1229 qemu_free_irq(s->ro_cb);
1230
1231 g_free(s->fifo_buffer);
1232 s->fifo_buffer = NULL;
1233}
1234
1235static bool sdhci_pending_insert_vmstate_needed(void *opaque)
1236{
1237 SDHCIState *s = opaque;
1238
1239 return s->pending_insert_state;
1240}
1241
1242static const VMStateDescription sdhci_pending_insert_vmstate = {
1243 .name = "sdhci/pending-insert",
1244 .version_id = 1,
1245 .minimum_version_id = 1,
1246 .needed = sdhci_pending_insert_vmstate_needed,
1247 .fields = (VMStateField[]) {
1248 VMSTATE_BOOL(pending_insert_state, SDHCIState),
1249 VMSTATE_END_OF_LIST()
1250 },
1251};
1252
1253const VMStateDescription sdhci_vmstate = {
1254 .name = "sdhci",
1255 .version_id = 1,
1256 .minimum_version_id = 1,
1257 .fields = (VMStateField[]) {
1258 VMSTATE_UINT32(sdmasysad, SDHCIState),
1259 VMSTATE_UINT16(blksize, SDHCIState),
1260 VMSTATE_UINT16(blkcnt, SDHCIState),
1261 VMSTATE_UINT32(argument, SDHCIState),
1262 VMSTATE_UINT16(trnmod, SDHCIState),
1263 VMSTATE_UINT16(cmdreg, SDHCIState),
1264 VMSTATE_UINT32_ARRAY(rspreg, SDHCIState, 4),
1265 VMSTATE_UINT32(prnsts, SDHCIState),
1266 VMSTATE_UINT8(hostctl, SDHCIState),
1267 VMSTATE_UINT8(pwrcon, SDHCIState),
1268 VMSTATE_UINT8(blkgap, SDHCIState),
1269 VMSTATE_UINT8(wakcon, SDHCIState),
1270 VMSTATE_UINT16(clkcon, SDHCIState),
1271 VMSTATE_UINT8(timeoutcon, SDHCIState),
1272 VMSTATE_UINT8(admaerr, SDHCIState),
1273 VMSTATE_UINT16(norintsts, SDHCIState),
1274 VMSTATE_UINT16(errintsts, SDHCIState),
1275 VMSTATE_UINT16(norintstsen, SDHCIState),
1276 VMSTATE_UINT16(errintstsen, SDHCIState),
1277 VMSTATE_UINT16(norintsigen, SDHCIState),
1278 VMSTATE_UINT16(errintsigen, SDHCIState),
1279 VMSTATE_UINT16(acmd12errsts, SDHCIState),
1280 VMSTATE_UINT16(data_count, SDHCIState),
1281 VMSTATE_UINT64(admasysaddr, SDHCIState),
1282 VMSTATE_UINT8(stopped_state, SDHCIState),
1283 VMSTATE_VBUFFER_UINT32(fifo_buffer, SDHCIState, 1, NULL, 0, buf_maxsz),
1284 VMSTATE_TIMER_PTR(insert_timer, SDHCIState),
1285 VMSTATE_TIMER_PTR(transfer_timer, SDHCIState),
1286 VMSTATE_END_OF_LIST()
1287 },
1288 .subsections = (const VMStateDescription*[]) {
1289 &sdhci_pending_insert_vmstate,
1290 NULL
1291 },
1292};
1293
1294
1295
1296static Property sdhci_pci_properties[] = {
1297 DEFINE_PROP_UINT32("capareg", SDHCIState, capareg,
1298 SDHC_CAPAB_REG_DEFAULT),
1299 DEFINE_PROP_UINT32("maxcurr", SDHCIState, maxcurr, 0),
1300 DEFINE_PROP_END_OF_LIST(),
1301};
1302
1303static void sdhci_pci_realize(PCIDevice *dev, Error **errp)
1304{
1305 SDHCIState *s = PCI_SDHCI(dev);
1306 dev->config[PCI_CLASS_PROG] = 0x01;
1307 dev->config[PCI_INTERRUPT_PIN] = 0x01;
1308 sdhci_initfn(s);
1309 s->buf_maxsz = sdhci_get_fifolen(s);
1310 s->fifo_buffer = g_malloc0(s->buf_maxsz);
1311 s->irq = pci_allocate_irq(dev);
1312 memory_region_init_io(&s->iomem, OBJECT(s), &sdhci_mmio_ops, s, "sdhci",
1313 SDHC_REGISTERS_MAP_SIZE);
1314 pci_register_bar(dev, 0, 0, &s->iomem);
1315}
1316
1317static void sdhci_pci_exit(PCIDevice *dev)
1318{
1319 SDHCIState *s = PCI_SDHCI(dev);
1320 sdhci_uninitfn(s);
1321}
1322
1323static void sdhci_pci_class_init(ObjectClass *klass, void *data)
1324{
1325 DeviceClass *dc = DEVICE_CLASS(klass);
1326 PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
1327
1328 k->realize = sdhci_pci_realize;
1329 k->exit = sdhci_pci_exit;
1330 k->vendor_id = PCI_VENDOR_ID_REDHAT;
1331 k->device_id = PCI_DEVICE_ID_REDHAT_SDHCI;
1332 k->class_id = PCI_CLASS_SYSTEM_SDHCI;
1333 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1334 dc->vmsd = &sdhci_vmstate;
1335 dc->props = sdhci_pci_properties;
1336 dc->reset = sdhci_poweron_reset;
1337}
1338
1339static const TypeInfo sdhci_pci_info = {
1340 .name = TYPE_PCI_SDHCI,
1341 .parent = TYPE_PCI_DEVICE,
1342 .instance_size = sizeof(SDHCIState),
1343 .class_init = sdhci_pci_class_init,
1344};
1345
1346static Property sdhci_sysbus_properties[] = {
1347 DEFINE_PROP_UINT32("capareg", SDHCIState, capareg,
1348 SDHC_CAPAB_REG_DEFAULT),
1349 DEFINE_PROP_UINT32("maxcurr", SDHCIState, maxcurr, 0),
1350 DEFINE_PROP_BOOL("pending-insert-quirk", SDHCIState, pending_insert_quirk,
1351 false),
1352 DEFINE_PROP_END_OF_LIST(),
1353};
1354
1355static void sdhci_sysbus_init(Object *obj)
1356{
1357 SDHCIState *s = SYSBUS_SDHCI(obj);
1358
1359 sdhci_initfn(s);
1360}
1361
1362static void sdhci_sysbus_finalize(Object *obj)
1363{
1364 SDHCIState *s = SYSBUS_SDHCI(obj);
1365 sdhci_uninitfn(s);
1366}
1367
1368static void sdhci_sysbus_realize(DeviceState *dev, Error ** errp)
1369{
1370 SDHCIState *s = SYSBUS_SDHCI(dev);
1371 SysBusDevice *sbd = SYS_BUS_DEVICE(dev);
1372
1373 s->buf_maxsz = sdhci_get_fifolen(s);
1374 s->fifo_buffer = g_malloc0(s->buf_maxsz);
1375 sysbus_init_irq(sbd, &s->irq);
1376 memory_region_init_io(&s->iomem, OBJECT(s), &sdhci_mmio_ops, s, "sdhci",
1377 SDHC_REGISTERS_MAP_SIZE);
1378 sysbus_init_mmio(sbd, &s->iomem);
1379 s->dma_as = s->dma_mr ? address_space_init_shareable(s->dma_mr, NULL)
1380 : &address_space_memory;
1381}
1382
1383static void sdhci_sysbus_class_init(ObjectClass *klass, void *data)
1384{
1385 DeviceClass *dc = DEVICE_CLASS(klass);
1386
1387 dc->vmsd = &sdhci_vmstate;
1388 dc->props = sdhci_sysbus_properties;
1389 dc->realize = sdhci_sysbus_realize;
1390 dc->reset = sdhci_poweron_reset;
1391}
1392
1393static const TypeInfo sdhci_sysbus_info = {
1394 .name = TYPE_SYSBUS_SDHCI,
1395 .parent = TYPE_SYS_BUS_DEVICE,
1396 .instance_size = sizeof(SDHCIState),
1397 .instance_init = sdhci_sysbus_init,
1398 .instance_finalize = sdhci_sysbus_finalize,
1399 .class_init = sdhci_sysbus_class_init,
1400};
1401
1402static void sdhci_bus_class_init(ObjectClass *klass, void *data)
1403{
1404 SDBusClass *sbc = SD_BUS_CLASS(klass);
1405
1406 sbc->set_inserted = sdhci_set_inserted;
1407 sbc->set_readonly = sdhci_set_readonly;
1408}
1409
1410static const TypeInfo sdhci_bus_info = {
1411 .name = TYPE_SDHCI_BUS,
1412 .parent = TYPE_SD_BUS,
1413 .instance_size = sizeof(SDBus),
1414 .class_init = sdhci_bus_class_init,
1415};
1416
1417static void sdhci_register_types(void)
1418{
1419 type_register_static(&sdhci_pci_info);
1420 type_register_static(&sdhci_sysbus_info);
1421 type_register_static(&sdhci_bus_info);
1422}
1423
1424type_init(sdhci_register_types)
1425