drivers/storage: Add SD/MMC/eMMC driver based upon depthcharge

The SD/MMC support is broken into several pieces.  There are three main
data structures:
* sdhci_ctrlr - This is SDHCI controller specific and defined in
  include/device/sdhci.h
* sd_mmc_ctrlr - This contains generic controller management data and
  defined in include/device/sd_mmc_ctrlr.h
* storage_media - This contains the flash storage device management data
  and is defined in include/device/storage.h

The SD/MMC driver consists of several components:
* SDHCI controller code
  * bouncebuf.c
  * bouncebuf.h
  * pci_sdhci.c
  * sdhci.c
  * sdhci.h
  * sdhci_adma.c
  * sdhci_display.c
* Flash storage device support
  * mmc.c
  * mmc.h
  * sd.c
  * sd_mmc.c
  * sd_mmc.h
  * storage.c
  * storage.h
  * storage_erase.c
  * storage_write.c

Kconfig values enable various portions of the controller and storage
drivers to be built to reduce the overall size of what is included in
the final image.

Full read/write/erase operations are provided for those platforms which
want to take advantage.  It is also possible to build the driver to
perform initialization only.  By default, this driver is not included in
any platform, platforms must specifically select DRIVERS_STORAGE to add
the SD/MMC support.

After this patch is reviewed and merged, there are some additional
patches:
* Common CAR storage area - Use a predefined region of CAR to pass data
  structures between bootblock through to romstage.  This allows early
  stages to preform the SD/MMC device initialization and later stages
  to use the SD/MMC device without further initialization.  The example
  code initializes the SD/MMC device in bootblock and uses the SD/MMC
  device in romstage without further initialization.
* CBMEM ID - Add a CBMEM ID value for the data structures so that they
  may be passed from romstage to ramstage and eventually the payload.
  The example uses the SD/MMC device in ramstage without further
  initialization.
* Move the SD/MMC driver into commonlib
* Have libpayload build the SD/MMC driver from commonlib.  The intent
  is to pass the controller state to libpayload so that the SD/MMC
  device can be used without further initialization.
* On some platforms, have depthcharge use the commonlib SD/MMC driver


History:

Copy the SD/MMC driver from depthcharge revision eb583fa8 into coreboot
and make the following changes:

* Removed #include "config.h" from mmc.c, allow the lint tests to pass.
* Move include files from drivers/storage into include/device.
* Rename mmc.h to storage.h.
* Add the Kconfig and Makefile and make edits to get the code to build.
* Add support to initialize a PCI controller.
* Fix formatting issues detected by checkpatch.
* Fix data flow issues detected by checkpatch.
* Add the missing voltage (MMC_VDD_35_36) into the voltage mask.
* Rename the macros mmc_debug, mmc_trace and mmc_error to sd_mmc_*.
* Replace printf with sd_mmc_error.
* Add sdhc_debug, sdhc_trace and sd_error macros.
* Add Kconfig values to enable storage device debugging and tracing.
* Add tracing and debug support to the SDHCI driver.
* Allow SOC to override more controller features.
* Split out ADMA support.
* Move 1V8 support into SOC routine.
* Move HS400 support into SOC routine.
* Rework clock handling.
* Change all controller references to use ctrlr.
* Update the voltage handling.
* Update modes of operation.
* Move DMA fields into MmcCtrlr.
* Update bus width support.
* Change MMC_TIMING_* to BUS_TIMING_*.
* Rename MMC_MODE_ to DRVR_CAP.
* Move quirks into ctrlr->caps.
* Associate removeable with the controller.
* Statically allocate MmcMedia.
* Replace the SdhciHost structure with the MmcCtrlr structure.
* Split the code to support other SD/MMC controllers.
* Split out erase and write support.
* Update the code to be more consistent with the coreboot coding style.
* Only expose calling APIs.
* Divide up mmc.c into 4 modules: MMC, SD, storage card, common code.
* Update debug and error messages.
* Add partition support.
* Display clock frequencies once in MHz.
* Remove mmc_send_cmd, use ctrlr->send_cmd instead.
* Handle error from sd_send_op_cond.
* Allow mainboard to control delays around CMD 0.
* Support command logging.
* Mainboard may set delay after SD/MMC command.
* Display serial number with sd_mmc_trace.
* Remove cmd set parameter from mmc_switch.
* Display errors for timeout and comm errors.
* Add LED support.
* Move 64bit DMA flag into ctrlr->caps.
* Rework PIO transfer routine.
* Add HS200 bus tuning.
* Add support for HS400.
* Use same format for HS400, HS200 and HS52.
* Reduce storage_media structure size
* Add routine to update code pointers
* Add display of storage setup
* Display controller setup

TEST=Build and run on Reef and Galileo Gen2

Change-Id: I9b5f9db1e27833e4ce4a97ad4f5ef3a46f64f2a2
Signed-off-by: Lee Leahy <leroy.p.leahy@intel.com>
Reviewed-on: https://review.coreboot.org/19208
Tested-by: build bot (Jenkins)
Reviewed-by: Stefan Reinauer <stefan.reinauer@coreboot.org>

1 files changed, 289 insertions, 0 deletions

diff --git a/src/drivers/storage/sd.c b/src/drivers/storage/sd.c
new file mode 100644
index 0000000000..18d2c0e245
--- /dev/null
+++ b/src/drivers/storage/sd.c
@@ -0,0 +1,289 @@
+/*
+ * Copyright 2008, Freescale Semiconductor, Inc
+ * Andy Fleming
+ *
+ * Copyright 2013 Google Inc.  All rights reserved.
+ * Copyright 2017 Intel Corporation
+ *
+ * Secure Digital (SD) card specific support code
+ * This code is controller independent
+ *
+ * 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.
+ */
+
+#include <assert.h>
+#include <delay.h>
+#include <device/sd_mmc_ctrlr.h>
+#include <device/storage.h>
+#include <endian.h>
+#include "sd_mmc.h"
+#include "storage.h"
+#include <string.h>
+#include <timer.h>
+
+int sd_send_if_cond(struct storage_media *media)
+{
+	struct mmc_command cmd;
+	struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
+
+	cmd.cmdidx = SD_CMD_SEND_IF_COND;
+	/* Set if controller supports voltages between 2.7 and 3.6 V. */
+	cmd.cmdarg = ((ctrlr->voltages & 0xff8000) != 0) << 8 | 0xaa;
+	cmd.resp_type = CARD_RSP_R7;
+	cmd.flags = 0;
+	int err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
+	if (err)
+		return err;
+
+	if ((cmd.response[0] & 0xff) != 0xaa)
+		return CARD_UNUSABLE_ERR;
+	media->version = SD_VERSION_2;
+	return 0;
+}
+
+int sd_send_op_cond(struct storage_media *media)
+{
+	int err;
+	struct mmc_command cmd;
+	struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
+
+	int tries = SD_MMC_IO_RETRIES;
+	while (tries--) {
+		cmd.cmdidx = MMC_CMD_APP_CMD;
+		cmd.resp_type = CARD_RSP_R1;
+		cmd.cmdarg = 0;
+		cmd.flags = 0;
+
+		err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
+		if (err)
+			return err;
+
+		cmd.cmdidx = SD_CMD_APP_SEND_OP_COND;
+		cmd.resp_type = CARD_RSP_R3;
+
+		/*
+		 * Most cards do not answer if some reserved bits
+		 * in the ocr are set. However, Some controller
+		 * can set bit 7 (reserved for low voltages), but
+		 * how to manage low voltages SD card is not yet
+		 * specified.
+		 */
+		cmd.cmdarg = (ctrlr->voltages & 0xff8000);
+
+		if (media->version == SD_VERSION_2)
+			cmd.cmdarg |= OCR_HCS;
+
+		err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
+		if (err)
+			return err;
+
+		// OCR_BUSY means "initialization complete".
+		if (cmd.response[0] & OCR_BUSY)
+			break;
+
+		udelay(100);
+	}
+	if (tries < 0)
+		return CARD_UNUSABLE_ERR;
+
+	if (media->version != SD_VERSION_2)
+		media->version = SD_VERSION_1_0;
+
+	media->ocr = cmd.response[0];
+	media->high_capacity = ((media->ocr & OCR_HCS) == OCR_HCS);
+	media->rca = 0;
+	return 0;
+}
+
+static int sd_switch(struct sd_mmc_ctrlr *ctrlr, int mode, int group,
+	uint8_t value, uint8_t *resp)
+{
+	/* Switch the frequency */
+	struct mmc_command cmd;
+	cmd.cmdidx = SD_CMD_SWITCH_FUNC;
+	cmd.resp_type = CARD_RSP_R1;
+	cmd.cmdarg = (mode << 31) | (0xffffff & ~(0xf << (group * 4))) |
+		     (value << (group * 4));
+	cmd.flags = 0;
+
+	struct mmc_data data;
+	data.dest = (char *)resp;
+	data.blocksize = 64;
+	data.blocks = 1;
+	data.flags = DATA_FLAG_READ;
+
+	return ctrlr->send_cmd(ctrlr, &cmd, &data);
+}
+
+static void sd_recalculate_clock(struct storage_media *media)
+{
+	uint32_t clock = 1;
+
+	if (media->caps & DRVR_CAP_HS)
+		clock = CLOCK_50MHZ;
+	else
+		clock = CLOCK_25MHZ;
+	SET_CLOCK(media->ctrlr, clock);
+}
+
+int sd_change_freq(struct storage_media *media)
+{
+	int err, timeout;
+	struct mmc_command cmd;
+	struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
+	struct mmc_data data;
+	ALLOC_CACHE_ALIGN_BUFFER(uint32_t, scr, 2);
+	ALLOC_CACHE_ALIGN_BUFFER(uint32_t, switch_status, 16);
+
+	media->caps = 0;
+
+	/* Read the SCR to find out if this card supports higher speeds */
+	cmd.cmdidx = MMC_CMD_APP_CMD;
+	cmd.resp_type = CARD_RSP_R1;
+	cmd.cmdarg = media->rca << 16;
+	cmd.flags = 0;
+
+	err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
+	if (err)
+		return err;
+
+	cmd.cmdidx = SD_CMD_APP_SEND_SCR;
+	cmd.resp_type = CARD_RSP_R1;
+	cmd.cmdarg = 0;
+	cmd.flags = 0;
+
+	timeout = 3;
+	while (timeout--) {
+		data.dest = (char *)scr;
+		data.blocksize = 8;
+		data.blocks = 1;
+		data.flags = DATA_FLAG_READ;
+		err = ctrlr->send_cmd(ctrlr, &cmd, &data);
+		if (!err)
+			break;
+	}
+	if (err) {
+		sd_mmc_error("%s returning %d\n", __func__, err);
+		return err;
+	}
+
+	media->scr[0] = be32toh(scr[0]);
+	media->scr[1] = be32toh(scr[1]);
+
+	switch ((media->scr[0] >> 24) & 0xf) {
+	case 0:
+		media->version = SD_VERSION_1_0;
+		break;
+	case 1:
+		media->version = SD_VERSION_1_10;
+		break;
+	case 2:
+		media->version = SD_VERSION_2;
+		break;
+	default:
+		media->version = SD_VERSION_1_0;
+		break;
+	}
+
+	if (media->scr[0] & SD_DATA_4BIT)
+		media->caps |= DRVR_CAP_4BIT;
+
+	/* Version 1.0 doesn't support switching */
+	if (media->version == SD_VERSION_1_0)
+		goto out;
+
+	timeout = 4;
+	while (timeout--) {
+		err = sd_switch(ctrlr, SD_SWITCH_CHECK, 0, 1,
+				(uint8_t *)switch_status);
+		if (err)
+			return err;
+
+		/* The high-speed function is busy.  Try again */
+		if (!(ntohl(switch_status[7]) & SD_HIGHSPEED_BUSY))
+			break;
+	}
+
+	/* If high-speed isn't supported, we return */
+	if (!(ntohl(switch_status[3]) & SD_HIGHSPEED_SUPPORTED))
+		goto out;
+
+	/*
+	 * If the controller doesn't support SD_HIGHSPEED, do not switch the
+	 * card to HIGHSPEED mode even if the card support SD_HIGHSPPED.
+	 * This can avoid a further problem when the card runs in different
+	 * mode than the controller.
+	 */
+	if (!((ctrlr->caps & DRVR_CAP_HS52) && (ctrlr->caps & DRVR_CAP_HS)))
+		goto out;
+
+	err = sd_switch(ctrlr, SD_SWITCH_SWITCH, 0, 1,
+			(uint8_t *)switch_status);
+	if (err)
+		return err;
+
+	if ((ntohl(switch_status[4]) & 0x0f000000) == 0x01000000) {
+		media->caps |= DRVR_CAP_HS;
+		SET_TIMING(ctrlr, BUS_TIMING_SD_HS);
+	}
+
+out:
+	sd_recalculate_clock(media);
+	return 0;
+}
+
+int sd_set_bus_width(struct storage_media *media)
+{
+	int err;
+	struct mmc_command cmd;
+	struct sd_mmc_ctrlr *ctrlr = media->ctrlr;
+
+	if (media->caps & DRVR_CAP_4BIT) {
+		cmd.cmdidx = MMC_CMD_APP_CMD;
+		cmd.resp_type = CARD_RSP_R1;
+		cmd.cmdarg = media->rca << 16;
+		cmd.flags = 0;
+
+		err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
+		if (err)
+			return err;
+
+		cmd.cmdidx = SD_CMD_APP_SET_BUS_WIDTH;
+		cmd.resp_type = CARD_RSP_R1;
+		cmd.cmdarg = 2;
+		cmd.flags = 0;
+		err = ctrlr->send_cmd(ctrlr, &cmd, NULL);
+		if (err)
+			return err;
+
+		SET_BUS_WIDTH(ctrlr, 4);
+	}
+	return 0;
+}
+
+
+int sd_set_partition(struct storage_media *media,
+	unsigned int partition_number)
+{
+	/* Validate the partition number */
+	if (partition_number)
+		return -1;
+
+	/* Update the partition number */
+	media->partition_config = partition_number;
+	return 0;
+}
+
+const char *sd_partition_name(struct storage_media *media,
+	unsigned int partition_number)
+{
+	return "";
+}