* [Qemu-devel] [PATCH v2 0/2] SDHCI for Xilinx Zynq
@ 2012-04-03 6:17 Peter A. G. Crosthwaite
2012-04-03 6:17 ` [Qemu-devel] [PATCH v2 1/2] SDHCI: inital version Peter A. G. Crosthwaite
2012-04-03 6:17 ` [Qemu-devel] [PATCH v2 2/2] xilinx_zynq: added sdhci controller Peter A. G. Crosthwaite
0 siblings, 2 replies; 3+ messages in thread
From: Peter A. G. Crosthwaite @ 2012-04-03 6:17 UTC (permalink / raw)
To: peter.crosthwaite, peter.maydell, qemu-devel, edgar.iglesias,
i.mitsyanko
Cc: kwolf, vpalatin, d.solodkiy, duyl, linnj, john.williams, paul
These two patched add a device model for the standard SD host controller interface (1) and instantiates it as a device to the Xilinx Zynq platform (2).
Peter A. G. Crosthwaite (2):
SDHCI: inital version
xilinx_zynq: added sdhci controller
Makefile.target | 1 +
hw/sdhci.c | 736 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
hw/xilinx_zynq.c | 13 +-
3 files changed, 749 insertions(+), 1 deletions(-)
create mode 100644 hw/sdhci.c
--
1.7.3.2
^ permalink raw reply [flat|nested] 3+ messages in thread
* [Qemu-devel] [PATCH v2 1/2] SDHCI: inital version
2012-04-03 6:17 [Qemu-devel] [PATCH v2 0/2] SDHCI for Xilinx Zynq Peter A. G. Crosthwaite
@ 2012-04-03 6:17 ` Peter A. G. Crosthwaite
2012-04-03 6:17 ` [Qemu-devel] [PATCH v2 2/2] xilinx_zynq: added sdhci controller Peter A. G. Crosthwaite
1 sibling, 0 replies; 3+ messages in thread
From: Peter A. G. Crosthwaite @ 2012-04-03 6:17 UTC (permalink / raw)
To: peter.crosthwaite, peter.maydell, qemu-devel, edgar.iglesias,
i.mitsyanko
Cc: kwolf, vpalatin, d.solodkiy, duyl, linnj, john.williams, paul
Device model for standard SD Host Controller Interface (SDHCI).
Signed-off-by: Peter A. G. Crosthwaite <peter.crosthwaite@petalogix.com>
---
changed from v1:
Made undefined op behaviour consisistent.
fixed compile warning.
Makefile.target | 1 +
hw/sdhci.c | 736 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 737 insertions(+), 0 deletions(-)
create mode 100644 hw/sdhci.c
diff --git a/Makefile.target b/Makefile.target
index 9b0cf74..c118dc6 100644
--- a/Makefile.target
+++ b/Makefile.target
@@ -363,6 +363,7 @@ obj-arm-y += versatile_pci.o
obj-arm-y += cadence_uart.o
obj-arm-y += cadence_ttc.o
obj-arm-y += cadence_gem.o
+obj-arm-y += sdhci.o
obj-arm-y += xilinx_zynq.o zynq_slcr.o
obj-arm-y += realview_gic.o realview.o arm_sysctl.o arm11mpcore.o a9mpcore.o
obj-arm-y += exynos4210_gic.o exynos4210_combiner.o exynos4210.o
diff --git a/hw/sdhci.c b/hw/sdhci.c
new file mode 100644
index 0000000..b387013
--- /dev/null
+++ b/hw/sdhci.c
@@ -0,0 +1,736 @@
+/*
+ * Copyright 2011 Google Inc.
+ * Copyright (C) 2012 Peter A.G. Crosthwaite <peter.crosthwaite@petalogix.com>
+ * Copyright (C) 2012 PetaLogix Pty Ltd.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ *
+ *
+ * SDHCI (SD Host Controler Interface) emulation
+ */
+
+#include "blockdev.h"
+#include "sysbus.h"
+#include "sd.h"
+
+#ifdef SDHCI_ERR_DEBUG
+#define DB_PRINT(...) do { \
+ fprintf(stderr, ": %s: ", __func__); \
+ fprintf(stderr, ## __VA_ARGS__); \
+ } while (0);
+#else
+ #define DB_PRINT(...)
+#endif
+
+
+/* Controller registers */
+
+#define SDHCI_DMA_ADDRESS 0x00
+
+#define SDHCI_BLOCK_SIZE 0x04
+
+#define SDHCI_BLOCK_COUNT 0x06
+
+#define SDHCI_ARGUMENT 0x08
+
+#define SDHCI_TRANSFER_MODE 0x0C
+#define SDHCI_TRNS_DMA 0x01
+#define SDHCI_TRNS_BLK_CNT_EN 0x02
+#define SDHCI_TRNS_ACMD12 0x04
+#define SDHCI_TRNS_READ 0x10
+#define SDHCI_TRNS_MULTI 0x20
+
+#define SDHCI_COMMAND 0x0E
+#define SDHCI_CMD_RESP_MASK 0x03
+#define SDHCI_CMD_CRC 0x08
+#define SDHCI_CMD_INDEX 0x10
+#define SDHCI_CMD_DATA 0x20
+
+#define SDHCI_CMD_RESP_NONE 0x00
+#define SDHCI_CMD_RESP_LONG 0x01
+#define SDHCI_CMD_RESP_SHORT 0x02
+#define SDHCI_CMD_RESP_SHORT_BUSY 0x03
+
+#define SDHCI_RESPONSE 0x10
+
+#define SDHCI_BUFFER 0x20
+
+#define SDHCI_PRESENT_STATE 0x24
+#define SDHCI_CMD_INHIBIT 0x00000001
+#define SDHCI_DATA_INHIBIT 0x00000002
+#define SDHCI_DOING_WRITE 0x00000100
+#define SDHCI_DOING_READ 0x00000200
+#define SDHCI_SPACE_AVAILABLE 0x00000400
+#define SDHCI_DATA_AVAILABLE 0x00000800
+#define SDHCI_CARD_PRESENT 0x00010000
+#define SDHCI_WRITE_PROTECT 0x00080000
+
+#define SDHCI_HOST_CONTROL 0x28
+#define SDHCI_CTRL_LED 0x01
+#define SDHCI_CTRL_4BITBUS 0x02
+#define SDHCI_CTRL_HISPD 0x04
+#define SDHCI_CTRL_DMA_MASK 0x18
+#define SDHCI_CTRL_SDMA 0x00
+#define SDHCI_CTRL_ADMA1 0x08
+#define SDHCI_CTRL_ADMA32 0x10
+#define SDHCI_CTRL_ADMA64 0x18
+#define SDHCI_CTRL_8BITBUS 0x20
+
+#define SDHCI_POWER_CONTROL 0x29
+#define SDHCI_POWER_ON 0x01
+#define SDHCI_POWER_180 0x0A
+#define SDHCI_POWER_300 0x0C
+#define SDHCI_POWER_330 0x0E
+
+#define SDHCI_BLOCK_GAP_CONTROL 0x2A
+
+#define SDHCI_WAKE_UP_CONTROL 0x2B
+#define SDHCI_WAKE_ON_INT 0x01
+#define SDHCI_WAKE_ON_INSERT 0x02
+#define SDHCI_WAKE_ON_REMOVE 0x04
+
+#define SDHCI_CLOCK_CONTROL 0x2C
+#define SDHCI_DIVIDER_SHIFT 8
+#define SDHCI_DIVIDER_HI_SHIFT 6
+#define SDHCI_DIV_MASK 0xFF
+#define SDHCI_DIV_MASK_LEN 8
+#define SDHCI_DIV_HI_MASK 0x300
+#define SDHCI_CLOCK_CARD_EN 0x0004
+#define SDHCI_CLOCK_INT_STABLE 0x0002
+#define SDHCI_CLOCK_INT_EN 0x0001
+
+#define SDHCI_TIMEOUT_CONTROL 0x2E
+
+#define SDHCI_SOFTWARE_RESET 0x2F
+#define SDHCI_RESET_ALL 0x01
+#define SDHCI_RESET_CMD 0x02
+#define SDHCI_RESET_DATA 0x04
+
+#define SDHCI_INT_STATUS 0x30
+#define SDHCI_INT_ENABLE 0x34
+#define SDHCI_SIGNAL_ENABLE 0x38
+#define SDHCI_INT_RESPONSE 0x00000001
+#define SDHCI_INT_DATA_END 0x00000002
+#define SDHCI_INT_DMA_END 0x00000008
+#define SDHCI_INT_SPACE_AVAIL 0x00000010
+#define SDHCI_INT_DATA_AVAIL 0x00000020
+#define SDHCI_INT_CARD_INSERT 0x00000040
+#define SDHCI_INT_CARD_REMOVE 0x00000080
+#define SDHCI_INT_CARD_INT 0x00000100
+#define SDHCI_INT_ERROR 0x00008000
+#define SDHCI_INT_TIMEOUT 0x00010000
+#define SDHCI_INT_CRC 0x00020000
+#define SDHCI_INT_END_BIT 0x00040000
+#define SDHCI_INT_INDEX 0x00080000
+#define SDHCI_INT_DATA_TIMEOUT 0x00100000
+#define SDHCI_INT_DATA_CRC 0x00200000
+#define SDHCI_INT_DATA_END_BIT 0x00400000
+#define SDHCI_INT_BUS_POWER 0x00800000
+#define SDHCI_INT_ACMD12ERR 0x01000000
+#define SDHCI_INT_ADMA_ERROR 0x02000000
+
+#define SDHCI_INT_NORMAL_MASK 0x00007FFF
+#define SDHCI_INT_ERROR_MASK 0xFFFF8000
+
+#define SDHCI_ACMD12_ERR 0x3C
+
+/* 3E-3F reserved */
+
+#define SDHCI_CAPABILITIES 0x40
+#define SDHCI_TIMEOUT_CLK_MASK 0x0000003F
+#define SDHCI_TIMEOUT_CLK_SHIFT 0
+#define SDHCI_TIMEOUT_CLK_UNIT 0x00000080
+#define SDHCI_CLOCK_BASE_MASK 0x00003F00
+#define SDHCI_CLOCK_V3_BASE_MASK 0x0000FF00
+#define SDHCI_CLOCK_BASE_SHIFT 8
+#define SDHCI_MAX_BLOCK_MASK 0x00030000
+#define SDHCI_MAX_BLOCK_SHIFT 16
+#define SDHCI_CAN_DO_8BIT 0x00040000
+#define SDHCI_CAN_DO_ADMA2 0x00080000
+#define SDHCI_CAN_DO_ADMA1 0x00100000
+#define SDHCI_CAN_DO_HISPD 0x00200000
+#define SDHCI_CAN_DO_SDMA 0x00400000
+#define SDHCI_CAN_VDD_330 0x01000000
+#define SDHCI_CAN_VDD_300 0x02000000
+#define SDHCI_CAN_VDD_180 0x04000000
+#define SDHCI_CAN_64BIT 0x10000000
+#define SDHCI_SLOT_TYPE_EMBED 0x40000000
+
+#define SDHCI_CAPABILITIES_1 0x44
+
+/* 44-47 reserved for more caps */
+
+#define SDHCI_MAX_CURRENT 0x48
+
+/* 4C-4F reserved for more max current */
+
+#define SDHCI_SET_ACMD12_ERROR 0x50
+#define SDHCI_SET_INT_ERROR 0x52
+
+#define SDHCI_ADMA_ERROR 0x54
+
+/* 55-57 reserved */
+
+#define SDHCI_ADMA_ADDRESS 0x58
+
+/* 60-FB reserved */
+
+#define SDHCI_SLOT_INT_STATUS 0xFC
+
+#define SDHCI_HOST_VERSION 0xFE
+#define SDHCI_VENDOR_VER_MASK 0xFF00
+#define SDHCI_VENDOR_VER_SHIFT 8
+#define SDHCI_SPEC_VER_MASK 0x00FF
+#define SDHCI_SPEC_VER_SHIFT 0
+#define SDHCI_SPEC_100 0
+#define SDHCI_SPEC_200 1
+#define SDHCI_SPEC_300 2
+
+/* ADMA descriptor flags */
+#define ADMA_VALID (1<<0)
+#define ADMA_END (1<<1)
+#define ADMA_INT (1<<2)
+
+#define ADMA_OP_MASK (3<<4)
+#define ADMA_OP_NOP (0<<4)
+#define ADMA_OP_SET (1<<4)
+#define ADMA_OP_TRAN (2<<4)
+#define ADMA_OP_LINK (3<<4)
+
+/* re-write a part of a variable using a mask
+ * to emulate the "byte-enable" behaviour in hardware
+ */
+#define MASKED_WRITE(var, val, mask) do {\
+ var = (var & ~(mask)) | ((val) & (mask));\
+ } while (0)
+
+typedef struct {
+ SysBusDevice busdev;
+ MemoryRegion iomem;
+ BlockDriverState *bs;
+ uint32_t sdma_address;
+ uint16_t block_size;
+ uint16_t block_count;
+ uint32_t arg;
+ uint16_t transfer_mode;
+ uint32_t response[4];
+ uint32_t clock;
+ uint32_t host_control;
+ uint32_t present_state;
+ uint32_t int_enable;
+ uint32_t int_status;
+ uint32_t adma_address;
+ uint8_t adma_error;
+ SDState *sd;
+ qemu_irq irq;
+ uint32_t pio_btt;
+} SDHCIState;
+
+static void sdhci_reset(DeviceState *d)
+{
+ SDHCIState *s = container_of(d, SDHCIState, busdev.qdev);
+
+ if (!s->bs) {
+ DriveInfo *inf = drive_get_next(IF_SD);
+ s->bs = inf ? inf->bdrv : NULL;
+ }
+ if (!s->sd && s->bs) {
+ s->sd = sd_init(s->bs, 0);
+ }
+
+ s->sdma_address = 0;
+ s->block_size = 0;
+ s->block_count = 0;
+ s->arg = 0;
+ s->transfer_mode = 0;
+ s->clock = SDHCI_CLOCK_INT_STABLE;
+ s->int_enable = 0;
+ s->int_status = 0;
+ s->adma_address = 0;
+ s->adma_error = 0;
+}
+
+static void sdhci_set_irq(SDHCIState *s)
+{
+ qemu_set_irq(s->irq, !!(s->int_status & s->int_enable));
+}
+
+static void sdhci_end_of_transfer(SDHCIState *s)
+{
+ DB_PRINT("\n");
+ SDRequest request;
+ uint8_t r[16];
+ request.cmd = 12;
+ request.arg = 0;
+ if (s->transfer_mode & SDHCI_TRNS_ACMD12) {
+ sd_do_command(s->sd, &request, r);
+ }
+ s->present_state &= ~(SDHCI_DOING_READ | SDHCI_DOING_WRITE);
+ s->int_status |= SDHCI_INT_DATA_END;
+ sdhci_set_irq(s);
+}
+
+static void pio_end_of_block(SDHCIState *s)
+{
+ DB_PRINT("\n");
+ if (!(s->transfer_mode & SDHCI_TRNS_MULTI)) {
+ sdhci_end_of_transfer(s);
+ return;
+ }
+
+ if ((s->transfer_mode & SDHCI_TRNS_BLK_CNT_EN)) {
+ if (!s->block_count) {
+ sdhci_end_of_transfer(s);
+ return;
+ }
+ s->block_count--;
+ }
+ s->pio_btt = s->block_size;
+ s->int_status |=
+ (s->present_state & SDHCI_DOING_READ) ? SDHCI_INT_DATA_AVAIL : 0;
+ s->int_status |=
+ (s->present_state & SDHCI_DOING_WRITE) ? SDHCI_INT_SPACE_AVAIL : 0;
+}
+
+static uint32_t do_pio_read(SDHCIState *s)
+{
+ int i;
+ uint32_t ret = 0;
+ if (!(s->present_state & SDHCI_DOING_READ)) {
+ DB_PRINT("reading pio data register in non-write state");
+ return 0;
+ }
+ for (i = 0; i < 4; ++i) {
+ ret = (ret >> 8) | ((uint32_t)sd_read_data(s->sd) << 24);
+ }
+ s->pio_btt -= 4;
+ if (!s->pio_btt) {
+ pio_end_of_block(s);
+ }
+ return ret;
+}
+
+static void do_pio_write(SDHCIState *s, uint32_t value)
+{
+ int i;
+ DB_PRINT("btt:%x\n", s->pio_btt);
+ if (!(s->present_state & SDHCI_DOING_WRITE)) {
+ DB_PRINT("writing pio data register in non-write state");
+ return;
+ }
+ for (i = 0; i < 4; ++i) {
+ sd_write_data(s->sd, (value >> (i*8)) & 0xff);
+ }
+ s->pio_btt -= 4;
+ if (!s->pio_btt) {
+ pio_end_of_block(s);
+ }
+}
+
+static void sdhci_pio_transfer(SDHCIState *s)
+{
+ DB_PRINT("\n");
+ s->present_state |= (s->transfer_mode & SDHCI_TRNS_READ) ?
+ SDHCI_DOING_READ : SDHCI_DOING_WRITE;
+ pio_end_of_block(s);
+}
+
+
+struct adma_desc {
+ uint16_t flags;
+ uint16_t size;
+ uint32_t addr;
+};
+
+static int sdhci_get_adma_desc(SDHCIState *s, struct adma_desc *ret,
+ uint32_t adma1_size)
+{
+ if (s->host_control & SDHCI_CTRL_ADMA32) { /* ADMA2 */
+ cpu_physical_memory_read(s->adma_address, (void *)ret, sizeof(*ret));
+ return sizeof(*ret);
+ } else { /* ADMA1 */
+ uint32_t adma1;
+ cpu_physical_memory_read(s->adma_address, (void *)&adma1,
+ sizeof(adma1));
+ ret->addr = adma1 & 0xfffff000;
+ ret->size = adma1_size;
+ ret->flags = adma1 & 0x3f;
+ return sizeof(adma1);
+ }
+}
+
+static void sdhci_dma_transfer(SDHCIState *s)
+{
+ int b;
+ uint16_t xfer_size;
+
+ uint32_t total_size, remaining_size;
+
+ struct adma_desc desc;
+ int adma_stride = 0;
+ s->adma_error = 0;
+ uint32_t adma1_size = (4 << 10);
+
+ DB_PRINT("");
+
+ if (s->host_control & SDHCI_CTRL_DMA_MASK) {
+ adma_stride = sdhci_get_adma_desc(s, &desc, adma1_size);
+ } else { /* use SDMA */
+ /* Generate hardcoded descriptor to emulate ADMA */
+ desc.addr = s->sdma_address;
+ desc.size = s->block_count * (s->block_size & 0xfff);
+ desc.flags = ADMA_VALID | ADMA_END | ADMA_OP_TRAN;
+ }
+ /* 0 in the size field means 65536 bytes */
+ remaining_size = desc.size ? desc.size : 65536;
+
+ s->int_status |= SDHCI_INT_DATA_END;
+
+ total_size = s->block_count*(s->block_size & 0xfff);
+ while (total_size) {
+ /* if the descriptor is invalid OR the desciptor is done OR the
+ * descriptor is not a transfer operation ...
+ */
+ while (!(desc.flags & ADMA_VALID) || !remaining_size ||
+ ((desc.flags & ADMA_OP_MASK) != ADMA_OP_TRAN)) {
+ if ((desc.flags & ADMA_END) || !(desc.flags & ADMA_VALID)) {
+ /* Abort ADMA transfer */
+ s->int_status |= SDHCI_INT_ADMA_ERROR;
+ s->adma_error = 1 /* ST_FDS */;
+ s->block_count = total_size / s->block_size;
+ return;
+ }
+ /* ADMA operation */
+ if ((desc.flags & ADMA_OP_MASK) == ADMA_OP_SET) {
+ adma1_size = (desc.addr >> 12) & 0xFFFF;
+ }
+ if ((desc.flags & ADMA_OP_MASK) == ADMA_OP_LINK) {
+ s->adma_address = desc.addr;
+ } else {
+ s->adma_address += adma_stride;
+ }
+ adma_stride = sdhci_get_adma_desc(s, &desc, adma1_size);
+ /* 0 in the size field means 65536 bytes */
+ remaining_size = desc.size ? desc.size : 65536;
+ }
+
+ xfer_size = MIN((s->block_size & 0xfff), remaining_size);
+ for (b = 0; b < xfer_size; b++, desc.addr++) {
+ if (s->transfer_mode & SDHCI_TRNS_READ) {
+ uint8_t data = sd_read_data(s->sd);
+ cpu_physical_memory_write(desc.addr, &data, 1);
+ } else {
+ uint8_t data;
+ cpu_physical_memory_read(desc.addr, &data, 1);
+ sd_write_data(s->sd, data);
+ }
+ }
+ remaining_size -= xfer_size;
+ total_size -= xfer_size;
+ }
+ sdhci_end_of_transfer(s);
+ s->block_count = 0;
+}
+
+static void sdhci_command(SDHCIState *s, uint32_t cmd)
+{
+ SDRequest request;
+ int len;
+ uint8_t r[16];
+
+ DB_PRINT("SDHCI command %08x\n", cmd);
+ if (!s->sd) { /* no SD device attached to the controller */
+ s->int_status |= SDHCI_INT_TIMEOUT;
+ sdhci_set_irq(s);
+ return;
+ }
+
+ request.cmd = (cmd>>8) & 0xff;
+ request.arg = s->arg;
+ len = sd_do_command(s->sd, &request, r);
+ if (len == 0) {
+ if (cmd & SDHCI_CMD_RESP_MASK) {
+ /* no response expected */
+ s->int_status |= SDHCI_INT_INDEX;
+ DB_PRINT("no response expected %08x\n", cmd);
+ } else {
+ /* error */
+ s->int_status |= SDHCI_INT_RESPONSE;
+ DB_PRINT("error response %08x\n", cmd);
+ }
+ } else {
+ DB_PRINT("actual response %08x\n", cmd);
+ if (len == 4) {
+ s->response[0] = (r[0]<<24) | (r[1]<<16) | (r[2]<<8) | r[3];
+ } else if (len == 16) {
+ s->response[0] = (r[11]<<24) | (r[12]<<16) | (r[13]<<8) | r[14];
+ s->response[1] = (r[7]<<24) | (r[8]<<16) | (r[9]<<8) | r[10];
+ s->response[2] = (r[3]<<24) | (r[4]<<16) | (r[5]<<8) | r[6];
+ s->response[3] = (0xcc<<24) | (r[0]<<16) | (r[1]<<8) | r[2];
+ }
+ s->int_status |= SDHCI_INT_RESPONSE;
+ if ((cmd & 3) == SDHCI_CMD_RESP_SHORT_BUSY) {
+ /* the command will trigger the busy (DAT[0]) line ON then OFF
+ * this will raise the Data END interrupt when done.
+ */
+ DB_PRINT("raising completion interrupt %08x\n", cmd);
+ s->int_status |= SDHCI_INT_DATA_END;
+ }
+ if (cmd & SDHCI_CMD_DATA) {
+ if (s->transfer_mode & SDHCI_TRNS_DMA) {
+ sdhci_dma_transfer(s);
+ } else {
+ sdhci_pio_transfer(s);
+ }
+ }
+ }
+ sdhci_set_irq(s);
+}
+
+static uint32_t sdhci_read32i(void *opaque, target_phys_addr_t offset)
+{
+ SDHCIState *s = opaque;
+
+ switch (offset) {
+ case SDHCI_DMA_ADDRESS:
+ return s->sdma_address;
+ case SDHCI_BLOCK_SIZE /* +SDHCI_BLOCK_COUNT */:
+ return s->block_size | (s->block_count << 16);
+ case SDHCI_ARGUMENT:
+ return s->arg;
+ case SDHCI_TRANSFER_MODE /* +SDHCI_COMMAND */:
+ return s->transfer_mode;
+ case SDHCI_RESPONSE:
+ case SDHCI_RESPONSE+4:
+ case SDHCI_RESPONSE+8:
+ case SDHCI_RESPONSE+12:
+ return s->response[(offset-SDHCI_RESPONSE)/sizeof(uint32_t)];
+ case SDHCI_BUFFER:
+ return do_pio_read(s);
+ case SDHCI_PRESENT_STATE:
+ return s->present_state | (s->sd ? 0x00170000 : 0) |
+ (s->bs && bdrv_is_read_only(s->bs) ? 0 : 0x00080000);
+ case SDHCI_HOST_CONTROL:
+ /*+SDHCI_POWER_CONTROL +SDHCI_BLOCK_GAP_CONTROL +SDHCI_WAKE_UP_CONTROL*/
+ return s->host_control;
+ case SDHCI_CLOCK_CONTROL /* +SDHCI_TIMEOUT_CONTROL +SDHCI_SOFTWARE_RESET */:
+ return s->clock | (0<<24 /* reset done */);
+ case SDHCI_INT_STATUS:
+ return s->int_status;
+ case SDHCI_INT_ENABLE:
+ return s->int_enable;
+ case SDHCI_SIGNAL_ENABLE:
+ return 0;
+ case SDHCI_ACMD12_ERR:
+ return 0;
+ case SDHCI_CAPABILITIES:
+ return SDHCI_SLOT_TYPE_EMBED | SDHCI_CAN_VDD_330 |
+ SDHCI_CAN_DO_ADMA1 | SDHCI_CAN_DO_HISPD | SDHCI_CAN_DO_SDMA |
+ SDHCI_CAN_DO_8BIT | SDHCI_CAN_DO_ADMA2 |
+ (52 << SDHCI_CLOCK_BASE_SHIFT) |
+ SDHCI_TIMEOUT_CLK_UNIT /* MHz */ | (52<<SDHCI_TIMEOUT_CLK_SHIFT);
+ case SDHCI_CAPABILITIES_1:
+ return 0;
+ case SDHCI_MAX_CURRENT:
+ return 0;
+ case SDHCI_SET_ACMD12_ERROR /* +SDHCI_SET_INT_ERROR */:
+ return 0;
+ case SDHCI_ADMA_ERROR:
+ return s->adma_error;
+ case SDHCI_ADMA_ADDRESS:
+ return s->adma_address;
+ case SDHCI_SLOT_INT_STATUS /* +SDHCI_HOST_VERSION */:
+ return 0 | (SDHCI_SPEC_200 << 16);
+ default:
+ DB_PRINT("Read from out of range offset");
+ }
+
+ return 0;
+}
+
+static uint64_t sdhci_read(void *opaque, target_phys_addr_t offset,
+ unsigned size)
+{
+ uint32_t ret = sdhci_read32i(opaque, offset & ~0x3);
+ ret >>= (offset & 0x3) * 8;
+ ret &= ~(-1ULL << (size * 8));
+ DB_PRINT("addr=" TARGET_FMT_plx " = %x\n", offset, ret);
+ return ret;
+}
+
+static void sdhci_write_masked(void *opaque, target_phys_addr_t offset,
+ uint32_t value, uint32_t mask)
+{
+ DB_PRINT("addr=" TARGET_FMT_plx " = %x, mask = %08x\n", offset, value,
+ mask);
+ SDHCIState *s = opaque;
+
+ switch (offset) {
+ case SDHCI_DMA_ADDRESS:
+ MASKED_WRITE(s->sdma_address, value, mask);
+ break;
+ case SDHCI_BLOCK_SIZE /* +SDHCI_BLOCK_COUNT */:
+ MASKED_WRITE(s->block_size, value & 0x7fff, mask);
+ MASKED_WRITE(s->block_count, value >> 16, mask >> 16);
+ break;
+ case SDHCI_ARGUMENT:
+ MASKED_WRITE(s->arg, value, mask);
+ break;
+ case SDHCI_TRANSFER_MODE /* +SDHCI_COMMAND */:
+ MASKED_WRITE(s->transfer_mode, value & 0x3f, mask);
+ if (mask & 0xffff0000) {
+ sdhci_command(s, value >> 16);
+ }
+ break;
+ case SDHCI_BUFFER:
+ do_pio_write(s, value);
+ break;
+ case SDHCI_HOST_CONTROL:
+ /*+SDHCI_POWER_CONTROL +SDHCI_BLOCK_GAP_CONTROL +SDHCI_WAKE_UP_CONTROL*/
+ MASKED_WRITE(s->host_control, value, mask);
+ if ((mask >> 8) & SDHCI_POWER_ON) {
+ if (s->sd) {
+ sd_enable(s->sd, ((value & mask) >> 8) & SDHCI_POWER_ON);
+ }
+ }
+ break;
+ case SDHCI_CLOCK_CONTROL /* +SDHCI_TIMEOUT_CONTROL +SDHCI_SOFTWARE_RESET */:
+ if (((value & mask) >> 24) & SDHCI_RESET_ALL) {
+ sdhci_reset(opaque);
+ }
+ if (((value & mask) >> 24) & SDHCI_RESET_CMD) {
+ s->int_status &= ~SDHCI_INT_RESPONSE;
+ sdhci_set_irq(s);
+ }
+ if (((value & mask) >> 24) & SDHCI_RESET_DATA) {
+ s->adma_error = 0;
+ s->int_status &= ~(SDHCI_INT_DATA_END | SDHCI_INT_DMA_END);
+ sdhci_set_irq(s);
+ }
+ MASKED_WRITE(s->clock, (value & 0xfffff) | SDHCI_CLOCK_INT_STABLE,
+ mask);
+ break;
+ case SDHCI_INT_STATUS:
+ s->int_status &= ~(value & mask);
+ sdhci_set_irq(s);
+ break;
+ case SDHCI_INT_ENABLE:
+ MASKED_WRITE(s->int_enable, value, mask);
+ sdhci_set_irq(s);
+ break;
+ case SDHCI_SIGNAL_ENABLE:
+ break;
+ case SDHCI_SET_ACMD12_ERROR /* +SDHCI_SET_INT_ERROR */:
+ break;
+ case SDHCI_ADMA_ADDRESS:
+ MASKED_WRITE(s->adma_address, value, mask);
+ break;
+ case SDHCI_SLOT_INT_STATUS /* +SDHCI_HOST_VERSION */:
+ break;
+ /* Read only registers */
+ case SDHCI_RESPONSE:
+ case SDHCI_RESPONSE+4:
+ case SDHCI_RESPONSE+8:
+ case SDHCI_RESPONSE+12:
+ case SDHCI_PRESENT_STATE:
+ case SDHCI_ACMD12_ERR:
+ case SDHCI_CAPABILITIES:
+ case SDHCI_CAPABILITIES_1:
+ case SDHCI_MAX_CURRENT:
+ case SDHCI_ADMA_ERROR:
+ DB_PRINT("Ignored write to read only register");
+ break;
+ default:
+ DB_PRINT("Ignored write to out of range offset");
+ }
+}
+
+static void sdhci_write(void *opaque, target_phys_addr_t offset,
+ uint64_t value, unsigned size)
+{
+ uint32_t mask = (1ULL << (size * 8)) - 1;
+ int shift = 8 * (offset & 0x3);
+ sdhci_write_masked(opaque, offset & ~0x3, value << shift, mask << shift);
+}
+
+static const MemoryRegionOps sdhci_ops = {
+ .read = sdhci_read,
+ .write = sdhci_write,
+ .endianness = DEVICE_NATIVE_ENDIAN,
+};
+
+static const VMStateDescription sdhci_vmstate = {
+ .name = "sdhci",
+ .version_id = 0,
+ .fields = (VMStateField[]) {
+ VMSTATE_UINT32(sdma_address, SDHCIState),
+ VMSTATE_UINT16(block_size, SDHCIState),
+ VMSTATE_UINT16(block_count, SDHCIState),
+ VMSTATE_UINT32(arg, SDHCIState),
+ VMSTATE_UINT16(transfer_mode, SDHCIState),
+ VMSTATE_UINT32_ARRAY(response, SDHCIState, 4),
+ VMSTATE_UINT32(clock, SDHCIState),
+ VMSTATE_UINT32(int_enable, SDHCIState),
+ VMSTATE_UINT32(int_status, SDHCIState),
+ VMSTATE_UINT32(adma_address, SDHCIState),
+ VMSTATE_UINT8(adma_error, SDHCIState),
+ VMSTATE_END_OF_LIST()
+ }
+};
+
+static int sdhci_sysbus_init(SysBusDevice *dev)
+{
+ SDHCIState *s = FROM_SYSBUS(SDHCIState, dev);
+
+ if (s->bs) {
+ bdrv_detach_dev(s->bs, s);
+ }
+ sysbus_init_irq(dev, &s->irq);
+ memory_region_init_io(&s->iomem, &sdhci_ops, s, "sdhci", 0x100);
+ sysbus_init_mmio(dev, &s->iomem);
+
+ return 0;
+}
+
+static Property sdhci_properties[] = {
+ DEFINE_PROP_DRIVE("block", SDHCIState, bs),
+ DEFINE_PROP_END_OF_LIST(),
+};
+
+static void sdhci_sysbus_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ SysBusDeviceClass *sdc = SYS_BUS_DEVICE_CLASS(klass);
+
+ sdc->init = sdhci_sysbus_init;
+ dc->props = sdhci_properties;
+ dc->vmsd = &sdhci_vmstate;
+ dc->reset = sdhci_reset;
+}
+
+static TypeInfo sdhci_sysbus_info = {
+ .name = "sysbus_sdhci",
+ .parent = TYPE_SYS_BUS_DEVICE,
+ .instance_size = sizeof(SDHCIState),
+ .class_init = sdhci_sysbus_class_init,
+};
+
+static void sdhci_register_types(void)
+{
+ type_register_static(&sdhci_sysbus_info);
+}
+
+type_init(sdhci_register_types)
--
1.7.3.2
^ permalink raw reply related [flat|nested] 3+ messages in thread
* [Qemu-devel] [PATCH v2 2/2] xilinx_zynq: added sdhci controller
2012-04-03 6:17 [Qemu-devel] [PATCH v2 0/2] SDHCI for Xilinx Zynq Peter A. G. Crosthwaite
2012-04-03 6:17 ` [Qemu-devel] [PATCH v2 1/2] SDHCI: inital version Peter A. G. Crosthwaite
@ 2012-04-03 6:17 ` Peter A. G. Crosthwaite
1 sibling, 0 replies; 3+ messages in thread
From: Peter A. G. Crosthwaite @ 2012-04-03 6:17 UTC (permalink / raw)
To: peter.crosthwaite, peter.maydell, qemu-devel, edgar.iglesias,
i.mitsyanko
Cc: kwolf, vpalatin, d.solodkiy, duyl, linnj, john.williams, paul
Signed-off-by: Peter A. G. Crosthwaite <peter.crosthwaite@petalogix.com>
---
hw/xilinx_zynq.c | 13 ++++++++++++-
1 files changed, 12 insertions(+), 1 deletions(-)
diff --git a/hw/xilinx_zynq.c b/hw/xilinx_zynq.c
index 31d9e81..e92ebe0 100644
--- a/hw/xilinx_zynq.c
+++ b/hw/xilinx_zynq.c
@@ -161,6 +161,18 @@ static void zynq_init(ram_addr_t ram_size, const char *boot_device,
sysbus_create_varargs("cadence_ttc", 0xF8002000,
pic[69-IRQ_OFFSET], pic[70-IRQ_OFFSET], pic[71-IRQ_OFFSET], NULL);
+ dev = qdev_create(NULL, "sysbus_sdhci");
+ dinfo = drive_get(IF_SD, 0, 0);
+ if (dinfo) {
+ if (qdev_prop_set_drive(dev, "block", dinfo ? dinfo->bdrv : NULL)) {
+ fprintf(stderr, "ZYNQ: ERROR: bad sd data file specified\n");
+ }
+ }
+ qdev_init_nofail(dev);
+ busdev = sysbus_from_qdev(dev);
+ sysbus_mmio_map(busdev, 0, 0xE0100000);
+ sysbus_connect_irq(busdev, 0, pic[56-IRQ_OFFSET]);
+
for (n = 0; n < nb_nics; n++) {
nd = &nd_table[n];
if (n == 0) {
@@ -190,7 +202,6 @@ static QEMUMachine zynq_machine = {
.init = zynq_init,
.use_scsi = 1,
.max_cpus = 2,
- .no_sdcard = 1
};
static void zynq_machine_init(void)
--
1.7.3.2
^ permalink raw reply related [flat|nested] 3+ messages in thread
end of thread, other threads:[~2012-04-03 6:17 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2012-04-03 6:17 [Qemu-devel] [PATCH v2 0/2] SDHCI for Xilinx Zynq Peter A. G. Crosthwaite
2012-04-03 6:17 ` [Qemu-devel] [PATCH v2 1/2] SDHCI: inital version Peter A. G. Crosthwaite
2012-04-03 6:17 ` [Qemu-devel] [PATCH v2 2/2] xilinx_zynq: added sdhci controller Peter A. G. Crosthwaite
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.