diff options
| author | weety <[email protected]> | 2016-05-31 20:23:32 +0800 |
|---|---|---|
| committer | weety <[email protected]> | 2016-05-31 20:23:32 +0800 |
| commit | 94e1935f1f2149f4e98098fbd171c3e96acb0e14 (patch) | |
| tree | c775db6b6c5fdc5c6ae811b44a5791af40784e2a /components/drivers | |
| parent | 714f00679eed2c8d1e758c768cf7af57944a5f08 (diff) | |
| parent | c8cfc14b82c633c7153113ac1f753695254d4bd6 (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.h | 4 | ||||
| -rw-r--r-- | components/drivers/include/drivers/serial.h | 26 | ||||
| -rw-r--r-- | components/drivers/sdio/mmcsd_core.c | 30 | ||||
| -rw-r--r-- | components/drivers/serial/serial.c | 253 | ||||
| -rw-r--r-- | components/drivers/spi/SConscript | 3 | ||||
| -rw-r--r-- | components/drivers/spi/enc28j60.c | 2 | ||||
| -rw-r--r-- | components/drivers/spi/spi_flash.h | 36 | ||||
| -rw-r--r-- | components/drivers/spi/spi_flash_at45dbxx.c | 18 | ||||
| -rw-r--r-- | components/drivers/spi/spi_flash_at45dbxx.h | 24 | ||||
| -rw-r--r-- | components/drivers/spi/spi_flash_gd.c | 346 | ||||
| -rw-r--r-- | components/drivers/spi/spi_flash_gd.h | 32 | ||||
| -rw-r--r-- | components/drivers/spi/spi_flash_sst25vfxx.c | 18 | ||||
| -rw-r--r-- | components/drivers/spi/spi_flash_sst25vfxx.h | 18 | ||||
| -rw-r--r-- | components/drivers/spi/spi_flash_w25qxx.c | 23 | ||||
| -rw-r--r-- | components/drivers/spi/spi_flash_w25qxx.h | 26 |
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 |
