CARPLAY版本整理

MXC_A27-PCB4.5-270T/lib/sfud/port/sfud_port.c

@@ -0,0 +1,287 @@
+/*
+ * This file is part of the Serial Flash Universal Driver Library.
+ *
+ * Copyright (c) 2016-2018, Armink, <armink.ztl@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Function: Portable interface for each platform.
+ * Created on: 2016-04-23
+ */
+
+#include <sfud.h>
+#include <stdarg.h>
+
+#include "FreeRTOS.h"
+#include "spi.h"
+#include "errno.h"
+
+#define SFUD_SPI_MAX_HZ 35000000
+#define SFUD_QSPI_MAX_HZ SFUD_SPI_MAX_HZ
+
+/* read the JEDEC SFDP command must run at 50 MHz or less */
+#define SFUD_DEFAULT_SPI_CFG					\
+{												\
+	.mode = SPI_MODE_0,							\
+	.data_width = 8,							\
+	.max_hz = SFUD_SPI_MAX_HZ,					\
+	.qspi_max_hz = SFUD_QSPI_MAX_HZ,			\
+}
+
+static char log_buf[256];
+
+void sfud_log_debug(const char *file, const long line, const char *format, ...);
+#ifdef SFUD_USING_QSPI
+sfud_err enter_qspi_mode(const sfud_spi *spi);
+sfud_err exit_qspi_mode(const sfud_spi *spi);
+#endif
+
+
+/**
+ * SPI write data then read data
+ */
+static sfud_err spi_write_read(const sfud_spi *spi, const uint8_t *write_buf, size_t write_size, uint8_t *read_buf,
+		size_t read_size) {
+	sfud_err result = SFUD_SUCCESS;
+	struct spi_slave *slave;
+
+	configASSERT(spi);
+
+	if (write_size) {
+		configASSERT(write_buf);
+	}
+	if (read_size) {
+		configASSERT(read_buf);
+	}
+
+	slave = spi->user_data;
+	configASSERT(slave);
+
+	if (write_size && read_size) {
+		if (spi_send_then_recv(slave, write_buf, write_size, read_buf, read_size) != ENOERR) {
+			result = SFUD_ERR_TIMEOUT;
+		}
+	} else if (write_size) {
+		if (spi_send(slave, write_buf, write_size) < 0) {
+			result = SFUD_ERR_TIMEOUT;
+		}
+	} else {
+		if (spi_recv(slave, read_buf, read_size) < 0) {
+			result = SFUD_ERR_TIMEOUT;
+		}
+	}
+
+	return result;
+}
+
+#ifdef SFUD_USING_QSPI
+/**
+ * read flash data by QSPI
+ */
+static sfud_err qspi_read(const sfud_spi *spi, uint32_t addr, sfud_qspi_read_cmd_format *qspi_read_cmd_format,
+		uint8_t *read_buf, size_t read_size) {
+	sfud_err result = SFUD_SUCCESS;
+	struct spi_slave *slave;
+	struct qspi_message qspi_message = {0};
+	uint32_t align_size, left_size;
+	uint32_t retries = 0;
+
+	configASSERT(spi);
+	configASSERT(qspi_read_cmd_format);
+	configASSERT(read_buf);
+
+	slave = spi->user_data;
+	configASSERT(slave);
+
+	configASSERT(slave != NULL);
+
+
+    xSemaphoreTake(slave->xMutex, portMAX_DELAY);
+
+retry:
+	align_size = read_size & ~31;
+	left_size = read_size & 31;
+	if (align_size) {
+		enter_qspi_mode(spi);
+
+		/* initial message */
+		qspi_message.message.recv_buf = read_buf;
+		qspi_message.message.length = align_size;
+		qspi_message.message.cs_take	= 1;
+		qspi_message.message.cs_release = 1;
+
+		qspi_message.instruction.content = qspi_read_cmd_format->instruction;
+		qspi_message.instruction.qspi_lines = qspi_read_cmd_format->instruction_lines;
+		qspi_message.address.content = addr;
+		qspi_message.address.size = qspi_read_cmd_format->address_size;
+		qspi_message.address.qspi_lines = qspi_read_cmd_format->address_lines;
+		qspi_message.dummy_cycles = qspi_read_cmd_format->dummy_cycles;
+		qspi_message.qspi_data_lines = qspi_read_cmd_format->data_lines;
+
+	
+		/* transfer message */
+		result = slave->qspi_read(slave, &qspi_message);
+
+		exit_qspi_mode(spi);
+		if (result) {
+			if (retries++ < 3) {
+				goto retry;
+			}
+			result = SFUD_ERR_READ;
+			goto __exit;
+		}
+	}
+
+	if (left_size) {
+	
+		uint8_t cmd_data[5], cmd_size;
+		int i;
+
+		cmd_data[0] = SFUD_CMD_READ_DATA;
+		cmd_size = spi->flash->addr_in_4_byte ? 5 : 4;
+#if DEVICE_TYPE_SELECT == SPI_NAND_FLASH
+		addr += (align_size << 8);	//2byte addr + 1dummy byte.
+#else //#elif DEVICE_TYPE_SELECT == SPI_NOR_FLASH
+		addr += align_size;
+#endif
+		for (i = 1; i < cmd_size; i++)
+			cmd_data[i] = (addr >> ((cmd_size - (i + 1)) * 8)) & 0xFF;
+
+		result = spi->wr(spi, cmd_data, cmd_size, read_buf + align_size, left_size);
+	
+	}
+
+__exit:
+    xSemaphoreGive(slave->xMutex);
+
+	return result;
+}
+#endif /* SFUD_USING_QSPI */
+
+static void spi_lock(const sfud_spi *spi)
+{
+	struct spi_slave *slave;
+
+	configASSERT(spi);
+
+	slave = spi->user_data;
+	configASSERT(slave);
+
+	xSemaphoreTake(slave->xSfudMutex, portMAX_DELAY);
+}
+
+static void spi_unlock(const sfud_spi *spi)
+{
+	struct spi_slave *slave;
+
+	configASSERT(spi);
+
+	slave = spi->user_data;
+	configASSERT(slave);
+
+	xSemaphoreGive(slave->xSfudMutex);
+}
+
+static void retry_delay_100us(void) {
+	/* 100 microsecond delay */
+	vTaskDelay((configTICK_RATE_HZ * 1 + 9999) / 10000);
+}
+
+sfud_err sfud_spi_port_init(sfud_flash *flash) {
+	sfud_err result = SFUD_SUCCESS;
+	struct spi_slave *slave;
+	struct spi_configuration config = SFUD_DEFAULT_SPI_CFG;
+
+	/**
+	 * add your port spi bus and device object initialize code like this:
+	 * 1. rcc initialize
+	 * 2. gpio initialize
+	 * 3. spi device initialize
+	 * 4. flash->spi and flash->retry item initialize
+	 *	flash->spi.wr = spi_write_read; //Required
+	 *	flash->spi.qspi_read = qspi_read; //Required when QSPI mode enable
+	 *	flash->spi.lock = spi_lock;
+	 *	flash->spi.unlock = spi_unlock;
+	 *	flash->spi.user_data = &spix;
+	 *	flash->retry.delay = null;
+	 *	flash->retry.times = 10000; //Required
+	 */
+
+	slave = spi_open(flash->spi.name);
+	if (!slave) {
+		printf("%s open fail.\n", flash->spi.name);
+		return SFUD_ERR_NOT_FOUND;
+	}
+	slave->xSfudMutex = xSemaphoreCreateMutex();
+	spi_configure(slave, &config);
+
+	flash->spi.wr = spi_write_read;
+#ifdef 	SFUD_USING_QSPI
+	flash->spi.qspi_read = qspi_read;
+#endif
+	flash->spi.lock = spi_lock;
+	flash->spi.unlock = spi_unlock;
+	flash->spi.user_data = slave;
+	/* 100 microsecond delay */
+	flash->retry.delay = retry_delay_100us;
+	/* 60 seconds timeout */
+	flash->retry.times = 60 * 10000;
+	flash->spi.flash = flash;
+
+	return result;
+}
+
+/**
+ * This function is print debug info.
+ *
+ * @param file the file which has call this function
+ * @param line the line number which has call this function
+ * @param format output format
+ * @param ... args
+ */
+void sfud_log_debug(const char *file, const long line, const char *format, ...) {
+	va_list args;
+
+	/* args point to the first variable parameter */
+	va_start(args, format);
+	printf("[SFUD](%s:%ld) ", file, line);
+	/* must use vprintf to print */
+	vsnprintf(log_buf, sizeof(log_buf), format, args);
+	printf("%s\n", log_buf);
+	va_end(args);
+}
+
+/**
+ * This function is print routine info.
+ *
+ * @param format output format
+ * @param ... args
+ */
+void sfud_log_info(const char *format, ...) {
+	va_list args;
+
+	/* args point to the first variable parameter */
+	va_start(args, format);
+	printf("[SFUD]");
+	/* must use vprintf to print */
+	vsnprintf(log_buf, sizeof(log_buf), format, args);
+	printf("%s\n", log_buf);
+	va_end(args);
+}