summaryrefslogtreecommitdiff
path: root/components/drivers
diff options
context:
space:
mode:
authorweety <[email protected]>2016-05-31 20:23:32 +0800
committerweety <[email protected]>2016-05-31 20:23:32 +0800
commit94e1935f1f2149f4e98098fbd171c3e96acb0e14 (patch)
treec775db6b6c5fdc5c6ae811b44a5791af40784e2a /components/drivers
parent714f00679eed2c8d1e758c768cf7af57944a5f08 (diff)
parentc8cfc14b82c633c7153113ac1f753695254d4bd6 (diff)
Merge branch 'master' of https://github.com/RT-Thread/rt-thread into fixed
Diffstat (limited to 'components/drivers')
-rw-r--r--components/drivers/include/drivers/mmcsd_core.h4
-rw-r--r--components/drivers/include/drivers/serial.h26
-rw-r--r--components/drivers/sdio/mmcsd_core.c30
-rw-r--r--components/drivers/serial/serial.c253
-rw-r--r--components/drivers/spi/SConscript3
-rw-r--r--components/drivers/spi/enc28j60.c2
-rw-r--r--components/drivers/spi/spi_flash.h36
-rw-r--r--components/drivers/spi/spi_flash_at45dbxx.c18
-rw-r--r--components/drivers/spi/spi_flash_at45dbxx.h24
-rw-r--r--components/drivers/spi/spi_flash_gd.c346
-rw-r--r--components/drivers/spi/spi_flash_gd.h32
-rw-r--r--components/drivers/spi/spi_flash_sst25vfxx.c18
-rw-r--r--components/drivers/spi/spi_flash_sst25vfxx.h18
-rw-r--r--components/drivers/spi/spi_flash_w25qxx.c23
-rw-r--r--components/drivers/spi/spi_flash_w25qxx.h26
15 files changed, 759 insertions, 100 deletions
diff --git a/components/drivers/include/drivers/mmcsd_core.h b/components/drivers/include/drivers/mmcsd_core.h
index 1e5560b893..e474fa28a8 100644
--- a/components/drivers/include/drivers/mmcsd_core.h
+++ b/components/drivers/include/drivers/mmcsd_core.h
@@ -220,6 +220,10 @@ rt_inline rt_uint32_t fls(rt_uint32_t val)
return bit;
}
+#define MMCSD_HOST_PLUGED 0
+#define MMCSD_HOST_UNPLUGED 1
+
+int mmcsd_wait_cd_changed(rt_int32_t timeout);
void mmcsd_host_lock(struct rt_mmcsd_host *host);
void mmcsd_host_unlock(struct rt_mmcsd_host *host);
void mmcsd_req_complete(struct rt_mmcsd_host *host);
diff --git a/components/drivers/include/drivers/serial.h b/components/drivers/include/drivers/serial.h
index 3b0a009072..c7e99ed472 100644
--- a/components/drivers/include/drivers/serial.h
+++ b/components/drivers/include/drivers/serial.h
@@ -33,12 +33,15 @@
#define BAUD_RATE_2400 2400
#define BAUD_RATE_4800 4800
#define BAUD_RATE_9600 9600
+#define BAUD_RATE_19200 19200
#define BAUD_RATE_38400 38400
#define BAUD_RATE_57600 57600
#define BAUD_RATE_115200 115200
#define BAUD_RATE_230400 230400
#define BAUD_RATE_460800 460800
#define BAUD_RATE_921600 921600
+#define BAUD_RATE_2000000 2000000
+#define BAUD_RATE_3000000 3000000
#define DATA_BITS_5 5
#define DATA_BITS_6 6
@@ -106,7 +109,7 @@ struct serial_configure
rt_uint32_t parity :2;
rt_uint32_t bit_order :1;
rt_uint32_t invert :1;
- rt_uint32_t bufsz :16;
+ rt_uint32_t bufsz :16;
rt_uint32_t reserved :4;
};
@@ -115,15 +118,15 @@ struct serial_configure
*/
struct rt_serial_rx_fifo
{
- /* software fifo */
- rt_uint8_t *buffer;
+ /* software fifo */
+ rt_uint8_t *buffer;
- rt_uint16_t put_index, get_index;
+ rt_uint16_t put_index, get_index;
};
struct rt_serial_tx_fifo
{
- struct rt_completion completion;
+ struct rt_completion completion;
};
/*
@@ -131,13 +134,13 @@ struct rt_serial_tx_fifo
*/
struct rt_serial_rx_dma
{
- rt_bool_t activated;
+ rt_bool_t activated;
};
struct rt_serial_tx_dma
{
- rt_bool_t activated;
- struct rt_data_queue data_queue;
+ rt_bool_t activated;
+ struct rt_data_queue data_queue;
};
struct rt_serial_device
@@ -147,8 +150,8 @@ struct rt_serial_device
const struct rt_uart_ops *ops;
struct serial_configure config;
- void *serial_rx;
- void *serial_tx;
+ void *serial_rx;
+ void *serial_tx;
};
typedef struct rt_serial_device rt_serial_t;
@@ -163,7 +166,7 @@ struct rt_uart_ops
int (*putc)(struct rt_serial_device *serial, char c);
int (*getc)(struct rt_serial_device *serial);
- rt_size_t (*dma_transmit)(struct rt_serial_device *serial, const rt_uint8_t *buf, rt_size_t size, int direction);
+ rt_size_t (*dma_transmit)(struct rt_serial_device *serial, rt_uint8_t *buf, rt_size_t size, int direction);
};
void rt_hw_serial_isr(struct rt_serial_device *serial, int event);
@@ -174,4 +177,3 @@ rt_err_t rt_hw_serial_register(struct rt_serial_device *serial,
void *data);
#endif
-
diff --git a/components/drivers/sdio/mmcsd_core.c b/components/drivers/sdio/mmcsd_core.c
index 0cbf8f1892..adda6a4910 100644
--- a/components/drivers/sdio/mmcsd_core.c
+++ b/components/drivers/sdio/mmcsd_core.c
@@ -44,6 +44,8 @@ static struct rt_thread mmcsd_detect_thread;
static rt_uint8_t mmcsd_stack[RT_MMCSD_STACK_SIZE];
static struct rt_mailbox mmcsd_detect_mb;
static rt_uint32_t mmcsd_detect_mb_pool[4];
+static struct rt_mailbox mmcsd_hotpluge_mb;
+static rt_uint32_t mmcsd_hotpluge_mb_pool[4];
void mmcsd_host_lock(struct rt_mmcsd_host *host)
{
@@ -594,6 +596,24 @@ static void mmcsd_power_off(struct rt_mmcsd_host *host)
mmcsd_set_iocfg(host);
}
+int mmcsd_wait_cd_changed(rt_int32_t timeout)
+{
+ struct rt_mmcsd_host *host;
+ if (rt_mb_recv(&mmcsd_hotpluge_mb, (rt_uint32_t*)&host, timeout) == RT_EOK)
+ {
+ if(host->card == RT_NULL)
+ {
+ return MMCSD_HOST_UNPLUGED;
+ }
+ else
+ {
+ return MMCSD_HOST_PLUGED;
+ }
+ }
+ return -RT_ETIMEOUT;
+}
+RTM_EXPORT(mmcsd_wait_cd_changed);
+
void mmcsd_change(struct rt_mmcsd_host *host)
{
rt_mb_send(&mmcsd_detect_mb, (rt_uint32_t)host);
@@ -647,6 +667,7 @@ void mmcsd_detect(void *param)
if (init_mmc(host, ocr))
mmcsd_power_off(host);
mmcsd_host_unlock(host);
+ rt_mb_send(&mmcsd_hotpluge_mb, (rt_uint32_t)host);
continue;
}
mmcsd_host_unlock(host);
@@ -667,6 +688,7 @@ void mmcsd_detect(void *param)
host->card = RT_NULL;
}
mmcsd_host_unlock(host);
+ rt_mb_send(&mmcsd_hotpluge_mb, (rt_uint32_t)host);
}
}
}
@@ -711,11 +733,15 @@ void rt_mmcsd_core_init(void)
/* initialize detect SD cart thread */
/* initialize mailbox and create detect SD card thread */
ret = rt_mb_init(&mmcsd_detect_mb, "mmcsdmb",
- &mmcsd_detect_mb_pool[0], sizeof(mmcsd_detect_mb_pool),
+ &mmcsd_detect_mb_pool[0], sizeof(mmcsd_detect_mb_pool) / sizeof(mmcsd_detect_mb_pool[0]),
RT_IPC_FLAG_FIFO);
RT_ASSERT(ret == RT_EOK);
- ret = rt_thread_init(&mmcsd_detect_thread, "mmcsd_detect", mmcsd_detect, RT_NULL,
+ ret = rt_mb_init(&mmcsd_hotpluge_mb, "mmcsdhotplugmb",
+ &mmcsd_hotpluge_mb_pool[0], sizeof(mmcsd_hotpluge_mb_pool) / sizeof(mmcsd_hotpluge_mb_pool[0]),
+ RT_IPC_FLAG_FIFO);
+ RT_ASSERT(ret == RT_EOK);
+ ret = rt_thread_init(&mmcsd_detect_thread, "mmcsd_detect", mmcsd_detect, RT_NULL,
&mmcsd_stack[0], RT_MMCSD_STACK_SIZE, RT_MMCSD_THREAD_PREORITY, 20);
if (ret == RT_EOK)
{
diff --git a/components/drivers/serial/serial.c b/components/drivers/serial/serial.c
index dbdfc5e578..7cb1c6b339 100644
--- a/components/drivers/serial/serial.c
+++ b/components/drivers/serial/serial.c
@@ -27,9 +27,10 @@
* the size of ring buffer.
* 2014-07-10 bernard rewrite serial framework
* 2014-12-31 bernard use open_flag for poll_tx stream mode.
- * 2015-05-19 Quintin fix DMA tx mod tx_dma->activated flag !=RT_FALSE BUG
+ * 2015-05-19 Quintin fix DMA tx mod tx_dma->activated flag !=RT_FALSE BUG
* in open function.
* 2015-11-10 bernard fix the poll rx issue when there is no data.
+ * 2016-05-10 armink add fifo mode to DMA rx when serial->config.bufsz != 0.
*/
#include <rthw.h>
@@ -37,13 +38,13 @@
#include <rtdevice.h>
/*
- * Serial poll routines
+ * Serial poll routines
*/
rt_inline int _serial_poll_rx(struct rt_serial_device *serial, rt_uint8_t *data, int length)
{
int ch;
int size;
-
+
RT_ASSERT(serial != RT_NULL);
size = length;
@@ -52,7 +53,7 @@ rt_inline int _serial_poll_rx(struct rt_serial_device *serial, rt_uint8_t *data,
ch = serial->ops->getc(serial);
if (ch == -1) break;
- *data = ch;
+ *data = ch;
data ++; length --;
if (ch == '\n') break;
@@ -77,9 +78,9 @@ rt_inline int _serial_poll_tx(struct rt_serial_device *serial, const rt_uint8_t
{
serial->ops->putc(serial, '\r');
}
-
+
serial->ops->putc(serial, *data);
-
+
++ data;
-- length;
}
@@ -96,8 +97,8 @@ rt_inline int _serial_int_rx(struct rt_serial_device *serial, rt_uint8_t *data,
struct rt_serial_rx_fifo* rx_fifo;
RT_ASSERT(serial != RT_NULL);
- size = length;
-
+ size = length;
+
rx_fifo = (struct rt_serial_rx_fifo*) serial->serial_rx;
RT_ASSERT(rx_fifo != RT_NULL);
@@ -136,7 +137,7 @@ rt_inline int _serial_int_tx(struct rt_serial_device *serial, const rt_uint8_t *
{
int size;
struct rt_serial_tx_fifo *tx;
-
+
RT_ASSERT(serial != RT_NULL);
size = length;
@@ -157,32 +158,136 @@ rt_inline int _serial_int_tx(struct rt_serial_device *serial, const rt_uint8_t *
return size - length;
}
+/**
+ * Calculate DMA received data length.
+ *
+ * @param serial serial device
+ *
+ * @return length
+ */
+static rt_size_t rt_dma_calc_recved_len(struct rt_serial_device *serial) {
+ static rt_size_t rx_length;
+ struct rt_serial_rx_fifo *rx_fifo = (struct rt_serial_rx_fifo *)serial->serial_rx;
+
+ RT_ASSERT(rx_fifo != RT_NULL);
+
+ rx_length = (rx_fifo->put_index >= rx_fifo->get_index)? (rx_fifo->put_index - rx_fifo->get_index):
+ (serial->config.bufsz - (rx_fifo->get_index - rx_fifo->put_index));
+ return rx_length;
+}
+
+/**
+ * Read data finish by DMA mode then update the gut index for receive fifo.
+ *
+ * @param serial serial device
+ * @param len get data length for this operate
+ */
+static void rt_dma_recv_update_get_index(struct rt_serial_device *serial, rt_size_t len) {
+ struct rt_serial_rx_fifo *rx_fifo = (struct rt_serial_rx_fifo *)serial->serial_rx;
+
+ RT_ASSERT(rx_fifo != RT_NULL);
+ RT_ASSERT(len <= rt_dma_calc_recved_len(serial));
+
+ rx_fifo->get_index += len;
+ if (rx_fifo->get_index > serial->config.bufsz ) {
+ rx_fifo->get_index -= serial->config.bufsz;
+ }
+}
+
+/**
+ * DMA received finish then update put index for receive fifo.
+ *
+ * @param serial serial device
+ * @param len received length for this transmit
+ */
+static void rt_dma_recv_update_put_index(struct rt_serial_device *serial, rt_size_t len) {
+ struct rt_serial_rx_fifo *rx_fifo = (struct rt_serial_rx_fifo *)serial->serial_rx;
+ rt_size_t i;
+
+ RT_ASSERT(rx_fifo != RT_NULL);
+
+ if (rx_fifo->get_index <= rx_fifo->put_index) {
+ rx_fifo->put_index += len;
+ /* beyond the fifo end */
+ if (rx_fifo->put_index >= serial->config.bufsz) {
+ for (i = 0; i <= len / serial->config.bufsz; i++) {
+ rx_fifo->put_index -= serial->config.bufsz;
+ }
+ /* force overwrite get index */
+ if (rx_fifo->put_index >= rx_fifo->get_index) {
+ rx_fifo->get_index = rx_fifo->put_index + 1;
+ }
+ }
+ } else {
+ rx_fifo->put_index += len;
+ if(rx_fifo->put_index >= rx_fifo->get_index) {
+ /* beyond the fifo end */
+ if(rx_fifo->put_index >= serial->config.bufsz) {
+ for (i = 0; i <= len / serial->config.bufsz; i++) {
+ rx_fifo->put_index -= serial->config.bufsz;
+ }
+ }
+ /* force overwrite get index */
+ rx_fifo->get_index = rx_fifo->put_index + 1;
+ }
+ }
+}
+
/*
* Serial DMA routines
*/
rt_inline int _serial_dma_rx(struct rt_serial_device *serial, rt_uint8_t *data, int length)
{
rt_base_t level;
- int result = RT_EOK;
- struct rt_serial_rx_dma *rx_dma;
RT_ASSERT((serial != RT_NULL) && (data != RT_NULL));
- rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx;
- RT_ASSERT(rx_dma != RT_NULL);
level = rt_hw_interrupt_disable();
- if (rx_dma->activated != RT_TRUE)
- {
- rx_dma->activated = RT_TRUE;
- serial->ops->dma_transmit(serial, data, length, RT_SERIAL_DMA_RX);
- }
- else result = -RT_EBUSY;
- rt_hw_interrupt_enable(level);
- if (result == RT_EOK) return length;
+ if (serial->config.bufsz == 0) {
+ int result = RT_EOK;
+ struct rt_serial_rx_dma *rx_dma;
+
+ rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx;
+ RT_ASSERT(rx_dma != RT_NULL);
+
+ if (rx_dma->activated != RT_TRUE)
+ {
+ rx_dma->activated = RT_TRUE;
+ RT_ASSERT(serial->ops->dma_transmit != RT_NULL);
+ serial->ops->dma_transmit(serial, data, length, RT_SERIAL_DMA_RX);
+ }
+ else result = -RT_EBUSY;
+ rt_hw_interrupt_enable(level);
+
+ if (result == RT_EOK) return length;
- rt_set_errno(result);
- return 0;
+ rt_set_errno(result);
+ return 0;
+ } else {
+ struct rt_serial_rx_fifo *rx_fifo = (struct rt_serial_rx_fifo *) serial->serial_rx;
+ rt_size_t recv_len = 0, fifo_recved_len = rt_dma_calc_recved_len(serial);
+
+ RT_ASSERT(rx_fifo != RT_NULL);
+
+ if (length < fifo_recved_len) {
+ recv_len = length;
+ } else {
+ recv_len = fifo_recved_len;
+ }
+
+ if (rx_fifo->get_index + recv_len < serial->config.bufsz) {
+ rt_memcpy(data, rx_fifo->buffer + rx_fifo->get_index, recv_len);
+ } else {
+ rt_memcpy(data, rx_fifo->buffer + rx_fifo->get_index,
+ serial->config.bufsz - rx_fifo->get_index);
+ rt_memcpy(data + serial->config.bufsz - rx_fifo->get_index, rx_fifo->buffer,
+ recv_len + rx_fifo->get_index - serial->config.bufsz);
+ }
+ rt_dma_recv_update_get_index(serial, recv_len);
+ rt_hw_interrupt_enable(level);
+ return recv_len;
+ }
}
rt_inline int _serial_dma_tx(struct rt_serial_device *serial, const rt_uint8_t *data, int length)
@@ -192,8 +297,8 @@ rt_inline int _serial_dma_tx(struct rt_serial_device *serial, const rt_uint8_t *
struct rt_serial_tx_dma *tx_dma;
tx_dma = (struct rt_serial_tx_dma*)(serial->serial_tx);
-
- result = rt_data_queue_push(&(tx_dma->data_queue), data, length, RT_WAITING_FOREVER);
+
+ result = rt_data_queue_push(&(tx_dma->data_queue), data, length, RT_WAITING_FOREVER);
if (result == RT_EOK)
{
level = rt_hw_interrupt_disable();
@@ -203,7 +308,7 @@ rt_inline int _serial_dma_tx(struct rt_serial_device *serial, const rt_uint8_t *
rt_hw_interrupt_enable(level);
/* make a DMA transfer */
- serial->ops->dma_transmit(serial, data, length, RT_SERIAL_DMA_TX);
+ serial->ops->dma_transmit(serial, (rt_uint8_t *)data, length, RT_SERIAL_DMA_TX);
}
else
{
@@ -250,7 +355,7 @@ static rt_err_t rt_serial_open(struct rt_device *dev, rt_uint16_t oflag)
serial = (struct rt_serial_device *)dev;
/* check device flag with the open flag */
- if ((oflag & RT_DEVICE_FLAG_DMA_RX) && !(dev->flag & RT_DEVICE_FLAG_DMA_RX))
+ if ((oflag & RT_DEVICE_FLAG_DMA_RX) && !(dev->flag & RT_DEVICE_FLAG_DMA_RX))
return -RT_EIO;
if ((oflag & RT_DEVICE_FLAG_DMA_TX) && !(dev->flag & RT_DEVICE_FLAG_DMA_TX))
return -RT_EIO;
@@ -261,26 +366,41 @@ static rt_err_t rt_serial_open(struct rt_device *dev, rt_uint16_t oflag)
/* get open flags */
dev->open_flag = oflag & 0xff;
-
+
/* initialize the Rx/Tx structure according to open flag */
if (serial->serial_rx == RT_NULL)
{
if (oflag & RT_DEVICE_FLAG_DMA_RX)
{
- struct rt_serial_rx_dma* rx_dma;
+ if (serial->config.bufsz == 0) {
+ struct rt_serial_rx_dma* rx_dma;
- rx_dma = (struct rt_serial_rx_dma*) rt_malloc (sizeof(struct rt_serial_rx_dma));
- RT_ASSERT(rx_dma != RT_NULL);
- rx_dma->activated = RT_FALSE;
+ rx_dma = (struct rt_serial_rx_dma*) rt_malloc (sizeof(struct rt_serial_rx_dma));
+ RT_ASSERT(rx_dma != RT_NULL);
+ rx_dma->activated = RT_FALSE;
- serial->serial_rx = rx_dma;
+ serial->serial_rx = rx_dma;
+ } else {
+ struct rt_serial_rx_fifo* rx_fifo;
+
+ rx_fifo = (struct rt_serial_rx_fifo*) rt_malloc (sizeof(struct rt_serial_rx_fifo) +
+ serial->config.bufsz);
+ RT_ASSERT(rx_fifo != RT_NULL);
+ rx_fifo->buffer = (rt_uint8_t*) (rx_fifo + 1);
+ rt_memset(rx_fifo->buffer, 0, serial->config.bufsz);
+ rx_fifo->put_index = 0;
+ rx_fifo->get_index = 0;
+ serial->serial_rx = rx_fifo;
+ /* configure fifo address and length to low level device */
+ serial->ops->control(serial, RT_DEVICE_CTRL_CONFIG, (void *) RT_DEVICE_FLAG_DMA_RX);
+ }
dev->open_flag |= RT_DEVICE_FLAG_DMA_RX;
}
else if (oflag & RT_DEVICE_FLAG_INT_RX)
{
struct rt_serial_rx_fifo* rx_fifo;
- rx_fifo = (struct rt_serial_rx_fifo*) rt_malloc (sizeof(struct rt_serial_rx_fifo) +
+ rx_fifo = (struct rt_serial_rx_fifo*) rt_malloc (sizeof(struct rt_serial_rx_fifo) +
serial->config.bufsz);
RT_ASSERT(rx_fifo != RT_NULL);
rx_fifo->buffer = (rt_uint8_t*) (rx_fifo + 1);
@@ -308,7 +428,7 @@ static rt_err_t rt_serial_open(struct rt_device *dev, rt_uint16_t oflag)
tx_dma = (struct rt_serial_tx_dma*) rt_malloc (sizeof(struct rt_serial_tx_dma));
RT_ASSERT(tx_dma != RT_NULL);
tx_dma->activated = RT_FALSE;
-
+
rt_data_queue_init(&(tx_dma->data_queue), 8, 4, RT_NULL);
serial->serial_tx = tx_dma;
@@ -346,7 +466,7 @@ static rt_err_t rt_serial_close(struct rt_device *dev)
/* this device has more reference count */
if (dev->ref_count > 1) return RT_EOK;
-
+
if (dev->open_flag & RT_DEVICE_FLAG_INT_RX)
{
struct rt_serial_rx_fifo* rx_fifo;
@@ -362,12 +482,23 @@ static rt_err_t rt_serial_close(struct rt_device *dev)
}
else if (dev->open_flag & RT_DEVICE_FLAG_DMA_RX)
{
- struct rt_serial_rx_dma* rx_dma;
+ if (serial->config.bufsz == 0) {
+ struct rt_serial_rx_dma* rx_dma;
- rx_dma = (struct rt_serial_rx_dma*)serial->serial_tx;
- RT_ASSERT(rx_dma != RT_NULL);
+ rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx;
+ RT_ASSERT(rx_dma != RT_NULL);
- rt_free(rx_dma);
+ rt_free(rx_dma);
+ } else {
+ struct rt_serial_rx_fifo* rx_fifo;
+
+ rx_fifo = (struct rt_serial_rx_fifo*)serial->serial_rx;
+ RT_ASSERT(rx_fifo != RT_NULL);
+
+ rt_free(rx_fifo);
+ }
+ /* configure low level device */
+ serial->ops->control(serial, RT_DEVICE_CTRL_CLR_INT, (void *) RT_DEVICE_FLAG_DMA_RX);
serial->serial_rx = RT_NULL;
dev->open_flag &= ~RT_DEVICE_FLAG_DMA_RX;
}
@@ -376,7 +507,7 @@ static rt_err_t rt_serial_close(struct rt_device *dev)
{
struct rt_serial_tx_fifo* tx_fifo;
- tx_fifo = (struct rt_serial_tx_fifo*)serial->serial_rx;
+ tx_fifo = (struct rt_serial_tx_fifo*)serial->serial_tx;
RT_ASSERT(tx_fifo != RT_NULL);
rt_free(tx_fifo);
@@ -534,30 +665,30 @@ void rt_hw_serial_isr(struct rt_serial_device *serial, int event)
ch = serial->ops->getc(serial);
if (ch == -1) break;
-
+
/* disable interrupt */
level = rt_hw_interrupt_disable();
-
+
rx_fifo->buffer[rx_fifo->put_index] = ch;
rx_fifo->put_index += 1;
if (rx_fifo->put_index >= serial->config.bufsz) rx_fifo->put_index = 0;
-
+
/* if the next position is read index, discard this 'read char' */
if (rx_fifo->put_index == rx_fifo->get_index)
{
rx_fifo->get_index += 1;
if (rx_fifo->get_index >= serial->config.bufsz) rx_fifo->get_index = 0;
}
-
+
/* enable interrupt */
rt_hw_interrupt_enable(level);
}
-
+
/* invoke callback */
if (serial->parent.rx_indicate != RT_NULL)
{
rt_size_t rx_length;
-
+
/* get rx length */
level = rt_hw_interrupt_disable();
rx_length = (rx_fifo->put_index >= rx_fifo->get_index)? (rx_fifo->put_index - rx_fifo->get_index):
@@ -584,19 +715,19 @@ void rt_hw_serial_isr(struct rt_serial_device *serial, int event)
struct rt_serial_tx_dma* tx_dma;
tx_dma = (struct rt_serial_tx_dma*) serial->serial_tx;
-
+
rt_data_queue_pop(&(tx_dma->data_queue), &last_data_ptr, &data_size, 0);
if (rt_data_queue_peak(&(tx_dma->data_queue), &data_ptr, &data_size) == RT_EOK)
{
/* transmit next data node */
tx_dma->activated = RT_TRUE;
- serial->ops->dma_transmit(serial, data_ptr, data_size, RT_SERIAL_DMA_TX);
+ serial->ops->dma_transmit(serial, (rt_uint8_t *)data_ptr, data_size, RT_SERIAL_DMA_TX);
}
else
{
tx_dma->activated = RT_FALSE;
}
-
+
/* invoke callback */
if (serial->parent.tx_complete != RT_NULL)
{
@@ -607,13 +738,27 @@ void rt_hw_serial_isr(struct rt_serial_device *serial, int event)
case RT_SERIAL_EVENT_RX_DMADONE:
{
int length;
- struct rt_serial_rx_dma* rx_dma;
- rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx;
/* get DMA rx length */
length = (event & (~0xff)) >> 8;
- serial->parent.rx_indicate(&(serial->parent), length);
- rx_dma->activated = RT_FALSE;
+
+ if (serial->config.bufsz == 0) {
+ struct rt_serial_rx_dma* rx_dma;
+
+ rx_dma = (struct rt_serial_rx_dma*)serial->serial_rx;
+ RT_ASSERT(rx_dma != RT_NULL);
+
+ RT_ASSERT(serial->parent.rx_indicate != RT_NULL);
+ serial->parent.rx_indicate(&(serial->parent), length);
+ rx_dma->activated = RT_FALSE;
+ } else {
+ /* update fifo put index */
+ rt_dma_recv_update_put_index(serial, length);
+ /* invoke callback */
+ if (serial->parent.rx_indicate != RT_NULL) {
+ serial->parent.rx_indicate(&(serial->parent), rt_dma_calc_recved_len(serial));
+ }
+ }
break;
}
}
diff --git a/components/drivers/spi/SConscript b/components/drivers/spi/SConscript
index 1047b8839a..e2baf6bab1 100644
--- a/components/drivers/spi/SConscript
+++ b/components/drivers/spi/SConscript
@@ -21,6 +21,9 @@ if GetDepend('RT_USING_AT45DBXX'):
if GetDepend('RT_USING_SST25VFXX'):
src_device += ['spi_flash_sst25vfxx.c']
+if GetDepend('RT_USING_GD'):
+ src_device += ['spi_flash_gd.c']
+
src += src_device
group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_SPI'], CPPPATH = CPPPATH)
diff --git a/components/drivers/spi/enc28j60.c b/components/drivers/spi/enc28j60.c
index 68f1181dcc..7152abdfd5 100644
--- a/components/drivers/spi/enc28j60.c
+++ b/components/drivers/spi/enc28j60.c
@@ -675,7 +675,7 @@ static struct pbuf *enc28j60_rx(rt_device_t dev)
else
{
/* allocation pbuf */
- p = pbuf_alloc(PBUF_LINK, len, PBUF_RAM);
+ p = pbuf_alloc(PBUF_LINK, len, PBUF_POOL);
if (p != RT_NULL)
{
struct pbuf* q;
diff --git a/components/drivers/spi/spi_flash.h b/components/drivers/spi/spi_flash.h
new file mode 100644
index 0000000000..59e7051ac0
--- /dev/null
+++ b/components/drivers/spi/spi_flash.h
@@ -0,0 +1,36 @@
+/*
+ * File : spi_flash.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2016, RT-Thread Development Team
+ *
+ * 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.
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2016/5/20 bernard the first version
+ */
+
+#ifndef SPI_FLASH_H__
+#define SPI_FLASH_H__
+
+struct spi_flash_device
+{
+ struct rt_device flash_device;
+ struct rt_device_blk_geometry geometry;
+ struct rt_spi_device * rt_spi_device;
+ struct rt_mutex lock;
+};
+
+#endif
diff --git a/components/drivers/spi/spi_flash_at45dbxx.c b/components/drivers/spi/spi_flash_at45dbxx.c
index be474f7c65..0585e395ca 100644
--- a/components/drivers/spi/spi_flash_at45dbxx.c
+++ b/components/drivers/spi/spi_flash_at45dbxx.c
@@ -1,11 +1,21 @@
/*
- * File : rtdef.h
+ * File : spi_flash_at45dbxx.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2011, RT-Thread Development Team
*
- * The license and distribution terms for this file may be
- * found in the file LICENSE in this distribution or at
- * http://www.rt-thread.org/license/LICENSE
+ * 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.
*
* Change Logs:
* Date Author Notes
diff --git a/components/drivers/spi/spi_flash_at45dbxx.h b/components/drivers/spi/spi_flash_at45dbxx.h
index 9b72cf0a0f..203a1d3ba9 100644
--- a/components/drivers/spi/spi_flash_at45dbxx.h
+++ b/components/drivers/spi/spi_flash_at45dbxx.h
@@ -1,3 +1,27 @@
+/*
+ * File : spi_flash_at45dbxx.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2011, RT-Thread Development Team
+ *
+ * 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.
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2011-12-16 aozima the first version
+ */
+
#ifndef SPI_FLASH_AT45DBXX_H_INCLUDED
#define SPI_FLASH_AT45DBXX_H_INCLUDED
diff --git a/components/drivers/spi/spi_flash_gd.c b/components/drivers/spi/spi_flash_gd.c
new file mode 100644
index 0000000000..e07b3ba3b1
--- /dev/null
+++ b/components/drivers/spi/spi_flash_gd.c
@@ -0,0 +1,346 @@
+/*
+ * File : spi_flash_gd.c
+ * This file is part of RT-Thread RTOS
+ * Copyright (c) 2016 Shanghai Fullhan Microelectronics Co., Ltd.
+ * All rights reserved
+ *
+ * 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.
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2015-10-11 fullhan copy from winbond flash
+ */
+
+#include <stdint.h>
+#include <rtthread.h>
+#include <rtdevice.h>
+
+#include "spi_flash.h"
+#include "spi_flash_gd.h"
+
+#define FLASH_DEBUG
+
+#ifdef FLASH_DEBUG
+#define FLASH_TRACE rt_kprintf
+#else
+#define FLASH_TRACE(...)
+#endif /* #ifdef FLASH_DEBUG */
+
+#define PAGE_SIZE 4096
+
+/* JEDEC Manufacturer's ID */
+#define MF_ID (0xC8)
+/* JEDEC Device ID: Memory type and Capacity */
+#define MTC_GD25Q128 (0x4018)
+
+/* command list */
+#define CMD_WRSR (0x01) /* Write Status Register */
+#define CMD_PP (0x02) /* Page Program */
+#define CMD_READ (0x03) /* Read Data */
+#define CMD_WRDI (0x04) /* Write Disable */
+#define CMD_RDSR1 (0x05) /* Read Status Register-1 */
+#define CMD_WREN (0x06) /* Write Enable */
+#define CMD_FAST_READ (0x0B) /* Fast Read */
+#define CMD_ERASE_4K (0x20) /* Sector Erase:4K */
+#define CMD_RDSR2 (0x35) /* Read Status Register-2 */
+#define CMD_ERASE_32K (0x52) /* 32KB Block Erase */
+#define CMD_JEDEC_ID (0x9F) /* Read JEDEC ID */
+#define CMD_ERASE_full (0xC7) /* Chip Erase */
+#define CMD_ERASE_64K (0xD8) /* 64KB Block Erase */
+
+#define DUMMY (0xFF)
+
+static struct spi_flash_device spi_flash_device;
+
+static void flash_lock(struct spi_flash_device * flash_device)
+{
+ rt_mutex_take(&flash_device->lock, RT_WAITING_FOREVER);
+}
+
+static void flash_unlock(struct spi_flash_device * flash_device)
+{
+ rt_mutex_release(&flash_device->lock);
+}
+
+static uint8_t w25qxx_read_status(void)
+{
+ return rt_spi_sendrecv8(spi_flash_device.rt_spi_device, CMD_RDSR1);
+}
+
+static void w25qxx_wait_busy(void)
+{
+ while( w25qxx_read_status() & (0x01));
+}
+
+/** \brief read [size] byte from [offset] to [buffer]
+ *
+ * \param offset uint32_t unit : byte
+ * \param buffer uint8_t*
+ * \param size uint32_t unit : byte
+ * \return uint32_t byte for read
+ *
+ */
+static uint32_t w25qxx_read(uint32_t offset, uint8_t * buffer, uint32_t size)
+{
+ uint8_t send_buffer[4];
+
+ send_buffer[0] = CMD_WRDI;
+ rt_spi_send(spi_flash_device.rt_spi_device, send_buffer, 1);
+
+ send_buffer[0] = CMD_READ;
+ send_buffer[1] = (uint8_t)(offset>>16);
+ send_buffer[2] = (uint8_t)(offset>>8);
+ send_buffer[3] = (uint8_t)(offset);
+
+ rt_spi_send_then_recv(spi_flash_device.rt_spi_device,
+ send_buffer, 4,
+ buffer, size);
+
+ return size;
+}
+
+/** \brief write N page on [page]
+ *
+ * \param page_addr uint32_t unit : byte (4096 * N,1 page = 4096byte)
+ * \param buffer const uint8_t*
+ * \return uint32_t
+ *
+ */
+static uint32_t w25qxx_page_write(uint32_t page_addr, const uint8_t* buffer)
+{
+ uint32_t index;
+ uint8_t send_buffer[4];
+
+ RT_ASSERT((page_addr&0xFF) == 0); /* page addr must align to 256byte. */
+
+ send_buffer[0] = CMD_WREN;
+ rt_spi_send(spi_flash_device.rt_spi_device, send_buffer, 1);
+
+ send_buffer[0] = CMD_ERASE_4K;
+ send_buffer[1] = (page_addr >> 16);
+ send_buffer[2] = (page_addr >> 8);
+ send_buffer[3] = (page_addr);
+ rt_spi_send(spi_flash_device.rt_spi_device, send_buffer, 4);
+
+ w25qxx_wait_busy(); // wait erase done.
+
+ for(index=0; index < (PAGE_SIZE / 256); index++)
+ {
+ send_buffer[0] = CMD_WREN;
+ rt_spi_send(spi_flash_device.rt_spi_device, send_buffer, 1);
+
+ send_buffer[0] = CMD_PP;
+ send_buffer[1] = (uint8_t)(page_addr >> 16);
+ send_buffer[2] = (uint8_t)(page_addr >> 8);
+ send_buffer[3] = (uint8_t)(page_addr);
+
+ rt_spi_send_then_send(spi_flash_device.rt_spi_device,
+ send_buffer,
+ 4,
+ buffer,
+ 256);
+
+ buffer += 256;
+ page_addr += 256;
+ w25qxx_wait_busy();
+ }
+
+ send_buffer[0] = CMD_WRDI;
+ rt_spi_send(spi_flash_device.rt_spi_device, send_buffer, 1);
+
+ return PAGE_SIZE;
+}
+
+/* RT-Thread device interface */
+static rt_err_t w25qxx_flash_init(rt_device_t dev)
+{
+ return RT_EOK;
+}
+
+static rt_err_t w25qxx_flash_open(rt_device_t dev, rt_uint16_t oflag)
+{
+ uint8_t send_buffer[3];
+
+ flash_lock((struct spi_flash_device *)dev);
+
+ send_buffer[0] = CMD_WREN;
+ rt_spi_send(spi_flash_device.rt_spi_device, send_buffer, 1);
+
+ send_buffer[0] = CMD_WRSR;
+ send_buffer[1] = 0;
+ send_buffer[2] = 0;
+ rt_spi_send(spi_flash_device.rt_spi_device, send_buffer, 3);
+
+ w25qxx_wait_busy();
+
+ flash_unlock((struct spi_flash_device *)dev);
+
+ return RT_EOK;
+}
+
+static rt_err_t w25qxx_flash_close(rt_device_t dev)
+{
+ return RT_EOK;
+}
+
+static rt_err_t w25qxx_flash_control(rt_device_t dev, rt_uint8_t cmd, void *args)
+{
+ RT_ASSERT(dev != RT_NULL);
+
+ if (cmd == RT_DEVICE_CTRL_BLK_GETGEOME)
+ {
+ struct rt_device_blk_geometry *geometry;
+
+ geometry = (struct rt_device_blk_geometry *)args;
+ if (geometry == RT_NULL) return -RT_ERROR;
+
+ geometry->bytes_per_sector = spi_flash_device.geometry.bytes_per_sector;
+ geometry->sector_count = spi_flash_device.geometry.sector_count;
+ geometry->block_size = spi_flash_device.geometry.block_size;
+ }
+
+ return RT_EOK;
+}
+
+static rt_size_t w25qxx_flash_read(rt_device_t dev,
+ rt_off_t pos,
+ void* buffer,
+ rt_size_t size)
+{
+ flash_lock((struct spi_flash_device *)dev);
+
+ w25qxx_read(pos*spi_flash_device.geometry.bytes_per_sector,
+ buffer,
+ size*spi_flash_device.geometry.bytes_per_sector);
+
+ flash_unlock((struct spi_flash_device *)dev);
+
+ return size;
+}
+
+static rt_size_t w25qxx_flash_write(rt_device_t dev,
+ rt_off_t pos,
+ const void* buffer,
+ rt_size_t size)
+{
+ rt_size_t i = 0;
+ rt_size_t block = size;
+ const uint8_t * ptr = buffer;
+
+ flash_lock((struct spi_flash_device *)dev);
+
+ while(block--)
+ {
+ w25qxx_page_write((pos + i)*spi_flash_device.geometry.bytes_per_sector,
+ ptr);
+ ptr += PAGE_SIZE;
+ i++;
+ }
+
+ flash_unlock((struct spi_flash_device *)dev);
+
+ return size;
+}
+
+rt_err_t gd_init(const char * flash_device_name, const char * spi_device_name)
+{
+ struct rt_spi_device * rt_spi_device;
+
+ /* initialize mutex */
+ if (rt_mutex_init(&spi_flash_device.lock, spi_device_name, RT_IPC_FLAG_FIFO) != RT_EOK)
+ {
+ rt_kprintf("init sd lock mutex failed\n");
+ return -RT_ENOSYS;
+ }
+
+ rt_spi_device = (struct rt_spi_device *)rt_device_find(spi_device_name);
+ if(rt_spi_device == RT_NULL)
+ {
+ FLASH_TRACE("spi device %s not found!\r\n", spi_device_name);
+ return -RT_ENOSYS;
+ }
+ spi_flash_device.rt_spi_device = rt_spi_device;
+
+ /* config spi */
+ {
+ struct rt_spi_configuration cfg;
+ cfg.data_width = 8;
+ cfg.mode = RT_SPI_MODE_0 | RT_SPI_MSB; /* SPI Compatible: Mode 0 and Mode 3 */
+ cfg.max_hz = 50 * 1000 * 1000; /* 50M */
+ rt_spi_configure(spi_flash_device.rt_spi_device, &cfg);
+ }
+
+ /* init flash */
+ {
+ rt_uint8_t cmd;
+ rt_uint8_t id_recv[3];
+ uint16_t memory_type_capacity;
+
+ flash_lock(&spi_flash_device);
+
+ cmd = 0xFF; /* reset SPI FLASH, cancel all cmd in processing. */
+ rt_spi_send(spi_flash_device.rt_spi_device, &cmd, 1);
+
+ cmd = CMD_WRDI;
+ rt_spi_send(spi_flash_device.rt_spi_device, &cmd, 1);
+
+ /* read flash id */
+ cmd = CMD_JEDEC_ID;
+ rt_spi_send_then_recv(spi_flash_device.rt_spi_device, &cmd, 1, id_recv, 3);
+
+ flash_unlock(&spi_flash_device);
+
+ if(id_recv[0] != MF_ID)
+ {
+ FLASH_TRACE("Manufacturers ID error!\r\n");
+ FLASH_TRACE("JEDEC Read-ID Data : %02X %02X %02X\r\n", id_recv[0], id_recv[1], id_recv[2]);
+ return -RT_ENOSYS;
+ }
+
+ spi_flash_device.geometry.bytes_per_sector = 4096;
+ spi_flash_device.geometry.block_size = 4096; /* block erase: 4k */
+
+ /* get memory type and capacity */
+ memory_type_capacity = id_recv[1];
+ memory_type_capacity = (memory_type_capacity << 8) | id_recv[2];
+
+ if(memory_type_capacity == MTC_GD25Q128)
+ {
+ FLASH_TRACE("GD128 detection\r\n");
+ spi_flash_device.geometry.sector_count = 4096;
+ }
+ else
+ {
+ FLASH_TRACE("Memory Capacity error!\r\n");
+ return -RT_ENOSYS;
+ }
+ }
+
+ /* register device */
+ spi_flash_device.flash_device.type = RT_Device_Class_Block;
+ spi_flash_device.flash_device.init = w25qxx_flash_init;
+ spi_flash_device.flash_device.open = w25qxx_flash_open;
+ spi_flash_device.flash_device.close = w25qxx_flash_close;
+ spi_flash_device.flash_device.read = w25qxx_flash_read;
+ spi_flash_device.flash_device.write = w25qxx_flash_write;
+ spi_flash_device.flash_device.control = w25qxx_flash_control;
+ /* no private */
+ spi_flash_device.flash_device.user_data = RT_NULL;
+
+ rt_device_register(&spi_flash_device.flash_device, flash_device_name,
+ RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
+
+ return RT_EOK;
+}
diff --git a/components/drivers/spi/spi_flash_gd.h b/components/drivers/spi/spi_flash_gd.h
new file mode 100644
index 0000000000..4a12100b74
--- /dev/null
+++ b/components/drivers/spi/spi_flash_gd.h
@@ -0,0 +1,32 @@
+/*
+ * File : spi_flash_gd.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2016, RT-Thread Development Team
+ *
+ * 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.
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2015-10-11 fullhan copy from winbond flash
+ */
+
+#ifndef SPI_FLASH_GD_H_
+#define SPI_FLASH_GD_H_
+
+#include <rtthread.h>
+
+extern rt_err_t gd_init(const char * flash_device_name, const char * spi_device_name);
+
+#endif /* SPI_FLASH_GD_H_ */
diff --git a/components/drivers/spi/spi_flash_sst25vfxx.c b/components/drivers/spi/spi_flash_sst25vfxx.c
index f0e28b5584..70f00f24d5 100644
--- a/components/drivers/spi/spi_flash_sst25vfxx.c
+++ b/components/drivers/spi/spi_flash_sst25vfxx.c
@@ -1,11 +1,21 @@
/*
- * File : rtdef.h
+ * File : spi_flash_sst25vfxx.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2011, RT-Thread Development Team
*
- * The license and distribution terms for this file may be
- * found in the file LICENSE in this distribution or at
- * http://www.rt-thread.org/license/LICENSE
+ * 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.
*
* Change Logs:
* Date Author Notes
diff --git a/components/drivers/spi/spi_flash_sst25vfxx.h b/components/drivers/spi/spi_flash_sst25vfxx.h
index b4575c2b68..2502188b91 100644
--- a/components/drivers/spi/spi_flash_sst25vfxx.h
+++ b/components/drivers/spi/spi_flash_sst25vfxx.h
@@ -1,11 +1,21 @@
/*
- * File : rtdef.h
+ * File : spi_flash_sst25vxx.h
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2011, RT-Thread Development Team
*
- * The license and distribution terms for this file may be
- * found in the file LICENSE in this distribution or at
- * http://www.rt-thread.org/license/LICENSE
+ * 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.
*
* Change Logs:
* Date Author Notes
diff --git a/components/drivers/spi/spi_flash_w25qxx.c b/components/drivers/spi/spi_flash_w25qxx.c
index 2237b971c4..2db997464f 100644
--- a/components/drivers/spi/spi_flash_w25qxx.c
+++ b/components/drivers/spi/spi_flash_w25qxx.c
@@ -3,9 +3,19 @@
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2011, RT-Thread Development Team
*
- * The license and distribution terms for this file may be
- * found in the file LICENSE in this distribution or at
- * http://www.rt-thread.org/license/LICENSE
+ * 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.
*
* Change Logs:
* Date Author Notes
@@ -13,10 +23,12 @@
* 2012-05-06 aozima can page write.
* 2012-08-23 aozima add flash lock.
* 2012-08-24 aozima fixed write status register BUG.
- * 2015-05-13 bernard add GD25Q flash ID.
*/
#include <stdint.h>
+#include <rtdevice.h>
+
+#include "spi_flash.h"
#include "spi_flash_w25qxx.h"
#define FLASH_DEBUG
@@ -31,7 +43,6 @@
/* JEDEC Manufacturer��s ID */
#define MF_ID (0xEF)
-#define GD_ID (0xC8)
/* JEDEC Device ID: Memory type and Capacity */
#define MTC_W25Q80_BV (0x4014) /* W25Q80BV */
@@ -301,7 +312,7 @@ rt_err_t w25qxx_init(const char * flash_device_name, const char * spi_device_nam
flash_unlock(&spi_flash_device);
- if(id_recv[0] != MF_ID && id_recv[0] != GD_ID)
+ if(id_recv[0] != MF_ID)
{
FLASH_TRACE("Manufacturers ID error!\r\n");
FLASH_TRACE("JEDEC Read-ID Data : %02X %02X %02X\r\n", id_recv[0], id_recv[1], id_recv[2]);
diff --git a/components/drivers/spi/spi_flash_w25qxx.h b/components/drivers/spi/spi_flash_w25qxx.h
index ebab35da33..737ca70ed2 100644
--- a/components/drivers/spi/spi_flash_w25qxx.h
+++ b/components/drivers/spi/spi_flash_w25qxx.h
@@ -3,9 +3,19 @@
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2011, RT-Thread Development Team
*
- * The license and distribution terms for this file may be
- * found in the file LICENSE in this distribution or at
- * http://www.rt-thread.org/license/LICENSE
+ * 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.
*
* Change Logs:
* Date Author Notes
@@ -17,18 +27,8 @@
#define SPI_FLASH_W25QXX_H_INCLUDED
#include <rtthread.h>
-#include <drivers/spi.h>
-
-struct spi_flash_device
-{
- struct rt_device flash_device;
- struct rt_device_blk_geometry geometry;
- struct rt_spi_device * rt_spi_device;
- struct rt_mutex lock;
-};
extern rt_err_t w25qxx_init(const char * flash_device_name,
const char * spi_device_name);
-
#endif // SPI_FLASH_W25QXX_H_INCLUDED