libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
rt-thread/bsp/fh8620/drivers/ssi.c

879 lines
23 KiB
C
Raw Blame History

/*
* This file is part of FH8620 BSP for RT-Thread distribution.
*
* 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.
*
* Visit http://www.fullhan.com to get contact with Fullhan.
*
* Change Logs:
* Date Author Notes
*/
#include <rtdevice.h>
#include <drivers/spi.h>
#include "fh_arch.h"
#include "board_info.h"
#include "ssi.h"
#include "gpio.h"
#include "inc/fh_driverlib.h"
#include "dma.h"
#include "dma_mem.h"
#include "mmu.h"
//#define FH_SPI_DEBUG
#ifdef FH_SPI_DEBUG
#define PRINT_SPI_DBG(fmt, args...) \
do \
{ \
rt_kprintf("FH_SPI_DEBUG: "); \
rt_kprintf(fmt, ## args); \
} \
while(0)
#else
#define PRINT_SPI_DBG(fmt, args...) do { } while (0)
#endif
#define RX_DMA_CHANNEL AUTO_FIND_CHANNEL
#define TX_DMA_CHANNEL AUTO_FIND_CHANNEL
#define DMA_OR_ISR_THRESHOLD 20
#define MALLOC_DMA_MEM_SIZE 0x1000
//static rt_uint32_t allign_func(rt_uint32_t in_addr,rt_uint32_t allign_size){
// return (in_addr + allign_size-1) & (~(allign_size - 1));
//}
void * fh_get_spi_dev_pri_data(struct rt_spi_device* device){
return device->parent.user_data;
}
static rt_err_t fh_spi_configure(struct rt_spi_device* device,
struct rt_spi_configuration* configuration)
{
struct spi_slave_info *spi_slave;
struct spi_controller *spi_control;
struct fh_spi_obj *spi_obj;
struct spi_config *config;
rt_uint32_t status;
rt_uint32_t spi_hz;
spi_slave = ( struct spi_slave_info *)fh_get_spi_dev_pri_data(device);
spi_control = spi_slave->control;
spi_obj = &spi_control->obj;
config = &spi_obj->config;
PRINT_SPI_DBG("configuration: \n");
PRINT_SPI_DBG("\tmode: 0x%x\n", configuration->mode);
PRINT_SPI_DBG("\tdata_width: 0x%x\n", configuration->data_width);
PRINT_SPI_DBG("\tmax_hz: 0x%x\n", configuration->max_hz);
do{
status = SPI_ReadStatus(spi_obj);
}
while(status & SPI_STATUS_BUSY);
/* data_width */
if(configuration->data_width <= 8){
config->data_size = SPI_DATA_SIZE_8BIT;
}
else if(configuration->data_width <= 16){
config->data_size = SPI_DATA_SIZE_16BIT;
}
else{
return -RT_ERROR;
}
if(configuration->max_hz > spi_control->max_hz)
spi_hz = spi_control->max_hz;
else
spi_hz = configuration->max_hz;
//fixme: div
config->clk_div = spi_control->clk_in/spi_hz;
//config->clk_div = 8;
PRINT_SPI_DBG("config hz:%d spi div:%d\n",spi_hz,config->clk_div);
/* CPOL */
if(configuration->mode & RT_SPI_CPOL){
config->clk_polarity = SPI_POLARITY_HIGH;
}
else{
config->clk_polarity = SPI_POLARITY_LOW;
}
/* CPHA */
if(configuration->mode & RT_SPI_CPHA){
config->clk_phase = SPI_PHASE_TX_FIRST;
}
else{
config->clk_phase = SPI_PHASE_RX_FIRST;
}
config->frame_format = SPI_FORMAT_MOTOROLA;
config->transfer_mode = SPI_MODE_TX_RX;
SPI_Enable(spi_obj, 0);
SPI_SetParameter(spi_obj);
SPI_DisableInterrupt(spi_obj, SPI_IRQ_ALL);
SPI_Enable(spi_obj, 1);
return RT_EOK;
}
static void xfer_dma_done(void *arg)
{
struct spi_controller *spi_control = (struct spi_controller *)arg;
spi_control->dma_complete_times++;
struct fh_spi_obj *spi_obj;
int ret;
rt_uint32_t slave_id;
spi_obj = &spi_control->obj;
//rt_kprintf("spi dma isr done.....\n");
if (spi_control->dma_complete_times == 2) {
spi_control->dma_complete_times = 0;
//add memcpy to user buff
if(spi_control->current_message->recv_buf){
rt_memcpy((void*)spi_control->current_message->recv_buf,(void*)spi_control->dma.rx_dummy_buff,spi_control->current_message->length);
}
SPI_Enable(spi_obj,0);
SPI_DisableDma(spi_obj,SPI_TX_DMA|SPI_RX_DMA);
SPI_Enable(spi_obj,1);
rt_completion_done(&spi_control->transfer_completion);
}
}
void dma_set_tx_data(struct spi_controller *spi_control){
struct dma_transfer *trans;
rt_uint32_t hs_no;
struct rt_spi_message* current_message = spi_control->current_message;
trans = &spi_control->dma.tx_trans;
hs_no = spi_control->dma.tx_hs;
struct fh_spi_obj *spi_obj;
spi_obj = &spi_control->obj;
if(current_message->length > MALLOC_DMA_MEM_SIZE){
rt_kprintf("[spi_dma]message len too large..\n");
rt_kprintf("[spi_dma] message len is %d,max len is %d\n",current_message->length,MALLOC_DMA_MEM_SIZE);
RT_ASSERT(current_message->length <= MALLOC_DMA_MEM_SIZE);
}
rt_memset((void*)spi_control->dma.tx_dummy_buff,0xff,current_message->length);
//copy tx data....
if(current_message->send_buf){
rt_memcpy(spi_control->dma.tx_dummy_buff,current_message->send_buf,current_message->length);
}
trans->dma_number = 0;
trans->dst_add = (rt_uint32_t)(spi_obj->base + OFFSET_SPI_DR);
trans->dst_hs = DMA_HW_HANDSHAKING;
trans->dst_inc_mode = DW_DMA_SLAVE_FIX;
trans->dst_msize = DW_DMA_SLAVE_MSIZE_1;
trans->dst_per = hs_no;
trans->dst_width = DW_DMA_SLAVE_WIDTH_8BIT;
trans->fc_mode = DMA_M2P;
trans->src_add = (rt_uint32_t)spi_control->dma.tx_dummy_buff;
trans->src_inc_mode = DW_DMA_SLAVE_INC;
trans->src_msize = DW_DMA_SLAVE_MSIZE_1;
trans->src_width = DW_DMA_SLAVE_WIDTH_8BIT;
trans->trans_len = current_message->length;
trans->complete_callback = (void *)xfer_dma_done;
trans->complete_para = (void *)spi_control;
}
void dma_set_rx_data(struct spi_controller *spi_control){
struct dma_transfer *trans;
rt_uint32_t hs_no;
struct rt_spi_message* current_message = spi_control->current_message;
trans = &spi_control->dma.rx_trans;
hs_no = spi_control->dma.rx_hs;
struct fh_spi_obj *spi_obj;
spi_obj = &spi_control->obj;
if(current_message->length > MALLOC_DMA_MEM_SIZE){
rt_kprintf("[spi_dma]message len too large..len is %d\n",current_message->length);
RT_ASSERT(current_message->length <= MALLOC_DMA_MEM_SIZE);
}
//rt_memset((void *)spi_control->dma.rx_dummy_buff,0,MALLOC_DMA_MEM_SIZE);
trans->dma_number = 0;
trans->fc_mode = DMA_P2M;
trans->dst_add = (rt_uint32_t)spi_control->dma.rx_dummy_buff;
trans->dst_inc_mode = DW_DMA_SLAVE_INC;
trans->dst_msize = DW_DMA_SLAVE_MSIZE_1;
trans->dst_width = DW_DMA_SLAVE_WIDTH_8BIT;
trans->src_add = (rt_uint32_t)(spi_obj->base + OFFSET_SPI_DR);
trans->src_inc_mode = DW_DMA_SLAVE_FIX;
trans->src_msize = DW_DMA_SLAVE_MSIZE_1;
trans->src_width = DW_DMA_SLAVE_WIDTH_8BIT;
trans->src_hs = DMA_HW_HANDSHAKING;
trans->src_per = hs_no;
trans->trans_len = current_message->length;
trans->complete_callback = (void *)xfer_dma_done;
trans->complete_para = (void *)spi_control;
}
rt_uint32_t xfer_data_dma(struct spi_controller *spi_control){
int ret;
struct fh_spi_obj *spi_obj;
spi_obj = &spi_control->obj;
struct rt_dma_device *dma_dev = spi_control->dma.dma_dev;
//tx data prepare
dma_set_tx_data(spi_control);
//rx data prepare
dma_set_rx_data(spi_control);
//dma go...
SPI_Enable(spi_obj,0);
//SPI_WriteTxDmaLevel(spi_obj,SPI_FIFO_DEPTH / 4);
SPI_WriteTxDmaLevel(spi_obj,1);
//SPI_WriteTxDmaLevel(spi_obj,0);
SPI_WriteRxDmaLevel(spi_obj,0);
SPI_EnableDma(spi_obj,SPI_TX_DMA|SPI_RX_DMA);
SPI_Enable(spi_obj,1);
dma_dev->ops->control(dma_dev,RT_DEVICE_CTRL_DMA_SINGLE_TRANSFER,(void *)&spi_control->dma.rx_trans);
dma_dev->ops->control(dma_dev,RT_DEVICE_CTRL_DMA_SINGLE_TRANSFER,(void *)&spi_control->dma.tx_trans);
ret = rt_completion_wait(&spi_control->transfer_completion, RT_TICK_PER_SECOND*50);
//release channel..
//dma_dev->ops->control(dma_dev,RT_DEVICE_CTRL_DMA_RELEASE_CHANNEL,(void *)&spi_control->dma.tx_trans);
//dma_dev->ops->control(dma_dev,RT_DEVICE_CTRL_DMA_RELEASE_CHANNEL,(void *)&spi_control->dma.rx_trans);
if(ret)
{
rt_kprintf("ERROR: %s, transfer timeout\n", __func__);
return -RT_ETIMEOUT;
}
return RT_EOK;
}
rt_uint32_t xfer_data_isr(struct spi_controller *spi_control){
int ret;
struct fh_spi_obj *spi_obj;
spi_obj = &spi_control->obj;
SPI_SetTxLevel(spi_obj, SPI_FIFO_DEPTH / 2);
SPI_EnableInterrupt(spi_obj, SPI_IRQ_TXEIM);
ret = rt_completion_wait(&spi_control->transfer_completion, RT_TICK_PER_SECOND*50);
if(ret)
{
rt_kprintf("ERROR: %s, transfer timeout\n", __func__);
return -RT_ETIMEOUT;
}
return RT_EOK;
}
void fix_spi_xfer_mode(struct spi_controller *spi_control){
//switch dma or isr....first check dma ...is error .use isr xfer...
struct rt_dma_device * rt_dma_dev;
struct dma_transfer *tx_trans;
struct dma_transfer *rx_trans;
int ret;
//retry to check if the dma status...
if(spi_control->dma.dma_flag == DMA_BIND_OK){
//if transfer data too short...use isr..
if(spi_control->current_message->length < DMA_OR_ISR_THRESHOLD){
spi_control->xfer_mode = XFER_USE_ISR;
return;
}
#if(0)
rt_dma_dev = spi_control->dma.dma_dev;
//first request channel
tx_trans = &spi_control->dma.tx_trans;
rx_trans = &spi_control->dma.rx_trans;
tx_trans->channel_number = TX_DMA_CHANNEL;
rx_trans->channel_number = RX_DMA_CHANNEL;
ret = rt_dma_dev->ops->control(rt_dma_dev,RT_DEVICE_CTRL_DMA_REQUEST_CHANNEL,(void *)tx_trans);
if(ret != RT_EOK){
spi_control->xfer_mode = XFER_USE_ISR;
return;
}
ret = rt_dma_dev->ops->control(rt_dma_dev,RT_DEVICE_CTRL_DMA_REQUEST_CHANNEL,(void *)rx_trans);
if(ret != RT_EOK){
//release tx channel...
rt_dma_dev->ops->control(rt_dma_dev,RT_DEVICE_CTRL_DMA_RELEASE_CHANNEL,(void *)&tx_trans);
spi_control->xfer_mode = XFER_USE_ISR;
return;
}
#endif
spi_control->xfer_mode = XFER_USE_DMA;
//if error use isr mode
}
else
spi_control->xfer_mode = XFER_USE_ISR;
}
static rt_uint32_t fh_spi_xfer(struct rt_spi_device* device, struct rt_spi_message* message)
{
struct spi_slave_info *spi_slave;
struct spi_controller *spi_control;
struct fh_spi_obj *spi_obj;
int ret;
rt_uint32_t slave_id;
spi_slave = ( struct spi_slave_info *)fh_get_spi_dev_pri_data(device);
spi_control = spi_slave->control;
spi_obj = &spi_control->obj;
spi_control->transfered_len = 0;
spi_control->received_len = 0;
rt_sem_take(&spi_control->xfer_lock, RT_WAITING_FOREVER);
rt_completion_init(&spi_control->transfer_completion);
spi_control->current_message = message;
/* take CS */
if(message->cs_take)
{
if(spi_slave->plat_slave.actice_level == ACTIVE_LOW)
gpio_direction_output(spi_slave->plat_slave.cs_pin, 0);
else
gpio_direction_output(spi_slave->plat_slave.cs_pin, 1);
//here will always use the slave_0 because that the cs is gpio...
SPI_EnableSlaveen(spi_obj, 0);
}
//fix transfer mode .....
fix_spi_xfer_mode(spi_control);
switch(spi_control->xfer_mode){
case XFER_USE_DMA:
PRINT_SPI_DBG("use dma xfer.....###############\n");
ret = xfer_data_dma(spi_control);
if(ret == RT_EOK){
break;
}
else{
//use the isr mode to transfer
spi_control->xfer_mode = XFER_USE_ISR;
rt_kprintf("%s dma transfer error no:%x\n",__func__,ret);
}
case XFER_USE_ISR:
PRINT_SPI_DBG("use isr xfer.....&&&&&&&&&&&&&\n");
ret = xfer_data_isr(spi_control);
if(ret != RT_EOK)
rt_kprintf("%s isr transfer error no:%x\n",__func__,ret);
break;
default:
rt_kprintf("%s unknow xfer func...\n",__func__);
while(1)
;
}
/* release CS */
if(message->cs_release)
{
if(spi_slave->plat_slave.actice_level == ACTIVE_LOW)
gpio_direction_output(spi_slave->plat_slave.cs_pin, 1);
else
gpio_direction_output(spi_slave->plat_slave.cs_pin, 0);
SPI_DisableSlaveen(spi_obj, 0);
}
rt_sem_release(&spi_control->xfer_lock);
PRINT_SPI_DBG("%s end\n", __func__);
return message->length;
}
static struct rt_spi_ops fh_spi_ops =
{
.configure = fh_spi_configure,
.xfer = fh_spi_xfer,
};
static void fh_spi_interrupt(int irq, void *param)
{
struct spi_controller *spi_control;
struct fh_spi_obj *spi_obj;
spi_control = (struct spi_controller *)param;
spi_obj = &spi_control->obj;
rt_uint32_t rx_fifo_capability,tx_fifo_capability;
rt_uint8_t data = 0;
rt_uint8_t *p;
rt_uint32_t status;
//
if(spi_control->current_message == RT_NULL){
rt_kprintf("ERROR: %s, current_message is incorrect\n", __func__);
}
status = SPI_InterruptStatus(spi_obj);
PRINT_SPI_DBG("status: 0x%x\n", status);
//fixme: ??recv overflow, underflow; tran overflow??
if(status & SPI_ISR_ERROR){
rt_kprintf("ERROR: %s, status=%d\n", __func__, status);
SPI_ClearInterrupt(spi_obj);
//fixme: handle error
return;
}
rx_fifo_capability = SPI_ReadRxFifoLevel(spi_obj);
tx_fifo_capability = MIN(
(SPI_FIFO_DEPTH - SPI_ReadTxFifoLevel(spi_obj)) / 2,
(spi_control->current_message->length - spi_control->transfered_len));
PRINT_SPI_DBG("rx_fifo_capability=%d\n", rx_fifo_capability);
//rx
spi_control->received_len += rx_fifo_capability;
while(rx_fifo_capability)
{
data = SPI_ReadData(spi_obj);
if(spi_control->current_message->recv_buf){
*(rt_uint8_t *)spi_control->current_message->recv_buf++ = data;
}
PRINT_SPI_DBG("rx, data: 0x%x\n", data);
//rt_kprintf("rx, data: 0x%x\n", data);
rx_fifo_capability--;
}
if(spi_control->received_len == spi_control->current_message->length)
{
//rt_kprintf("asdasdq4902834908dklfkldjsdhgkljshfgljkhsgfkljhsdfkljghklj");
SPI_DisableInterrupt(spi_obj, SPI_ISR_FLAG);
PRINT_SPI_DBG("finished, length=%d, received_len=%d\n", spi_control->current_message->length, spi_control->received_len);
rt_completion_done(&spi_control->transfer_completion);
return;
}
//tx
spi_control->transfered_len +=tx_fifo_capability;
if(spi_control->current_message->send_buf){
p = (rt_uint8_t *)spi_control->current_message->send_buf;
while(tx_fifo_capability){
PRINT_SPI_DBG("tx, data: 0x%x\n", *p);
//rt_kprintf("tx, data: 0x%x\n", *p);
SPI_WriteData(spi_obj, *p++);
tx_fifo_capability--;
}
spi_control->current_message->send_buf = p;
}
else{
while(tx_fifo_capability){
SPI_WriteData(spi_obj, 0xff);
tx_fifo_capability--;
}
}
}
int fh_spi_probe(void *priv_data)
{
char spi_dev_name[20] = {0};
char spi_bus_name[20] = {0};
char spi_isr_name[20] = {0};
char spi_lock_name[20] = {0};
struct spi_slave_info *spi_slave;
struct spi_slave_info *next_slave;
struct spi_slave_info **control_slave;
struct spi_controller *spi_control;
struct spi_control_platform_data *plat_data;
int i,ret;
struct rt_dma_device * rt_dma_dev;
struct dma_transfer *tx_trans;
struct dma_transfer *rx_trans;
//check data...
plat_data = (struct spi_control_platform_data *)priv_data;
if(!plat_data){
rt_kprintf("ERROR:platform data null...\n");
return -RT_ENOMEM;
}
if(plat_data->slave_no > FH_SPI_SLAVE_MAX_NO){
rt_kprintf("ERROR:spi controller not support %d slave..\n",plat_data->slave_no);
return -RT_ENOMEM;
}
//malloc data
spi_control = (struct spi_controller*)rt_malloc(sizeof(struct spi_controller));
if(!spi_control){
rt_kprintf("ERROR:no mem for malloc the spi controller..\n");
goto error_malloc_bus;
}
rt_memset(spi_control, 0, sizeof(struct spi_controller));
//parse platform control data
spi_control->base = plat_data->base;
spi_control->id = plat_data->id;
spi_control->irq = plat_data->irq;
spi_control->max_hz = plat_data->max_hz;
spi_control->slave_no = plat_data->slave_no;
spi_control->obj.base = plat_data->base;
spi_control->clk_in = plat_data->clk_in;
spi_control->plat_data = plat_data;
rt_sprintf(spi_lock_name, "%s%d", "spi_lock", spi_control->id);
rt_sem_init(&spi_control->xfer_lock, spi_lock_name, 1, RT_IPC_FLAG_FIFO);
rt_sprintf(spi_bus_name, "%s%d", "spi_bus", spi_control->id);
ret = rt_spi_bus_register(&spi_control->spi_bus, spi_bus_name, &fh_spi_ops);
PRINT_SPI_DBG("bus name is :%s\n",spi_bus_name);
//isr...
rt_sprintf(spi_isr_name, "%s%d", "ssi_isr", spi_control->id);
rt_hw_interrupt_install(spi_control->irq, fh_spi_interrupt,
(void *)spi_control, spi_isr_name);
rt_hw_interrupt_umask(spi_control->irq);
PRINT_SPI_DBG("isr name is :%s\n",spi_isr_name);
//check dma ....
if(plat_data->transfer_mode == USE_DMA_TRANSFER){
spi_control->dma.dma_dev = (struct rt_dma_device *)rt_device_find(plat_data->dma_name);
if(spi_control->dma.dma_dev == RT_NULL){
rt_kprintf("can't find dma dev\n");
//goto error_malloc_slave;
//spi_control->dma_xfer_flag = USE_ISR_TRANSFER;
// spi_control->dma.dma_flag = DMA_BIND_ERROR;
// spi_control->xfer_mode = XFER_USE_ISR;
goto BIND_DMA_ERROR;
}
else{
spi_control->dma.control = spi_control;
spi_control->dma.rx_hs = plat_data->rx_hs_no;
spi_control->dma.tx_hs = plat_data->tx_hs_no;
spi_control->dma.dma_name = plat_data->dma_name;
spi_control->dma.rx_dummy_buff = fh_dma_mem_malloc(MALLOC_DMA_MEM_SIZE);
if(!spi_control->dma.rx_dummy_buff){
rt_kprintf("malloc rx dma buff failed...\n");
//spi_control->xfer_mode = XFER_USE_ISR;
goto BIND_DMA_ERROR;
}
spi_control->dma.tx_dummy_buff = fh_dma_mem_malloc(MALLOC_DMA_MEM_SIZE);
if(!spi_control->dma.tx_dummy_buff){
rt_kprintf("malloc tx dma buff failed...\n");
fh_dma_mem_free(spi_control->dma.rx_dummy_buff);
//spi_control->xfer_mode = XFER_USE_ISR;
goto BIND_DMA_ERROR;
}
if(((rt_uint32_t)spi_control->dma.tx_dummy_buff % 4)||((rt_uint32_t)spi_control->dma.rx_dummy_buff % 4)){
rt_kprintf("dma malloc buff not allign..\n");
fh_dma_mem_free(spi_control->dma.rx_dummy_buff);
fh_dma_mem_free(spi_control->dma.tx_dummy_buff);
goto BIND_DMA_ERROR;
}
//open dma dev.
spi_control->dma.dma_dev->ops->control(spi_control->dma.dma_dev,RT_DEVICE_CTRL_DMA_OPEN,RT_NULL);
//request channel
rt_dma_dev = spi_control->dma.dma_dev;
//first request channel
tx_trans = &spi_control->dma.tx_trans;
rx_trans = &spi_control->dma.rx_trans;
tx_trans->channel_number = TX_DMA_CHANNEL;
rx_trans->channel_number = RX_DMA_CHANNEL;
ret = rt_dma_dev->ops->control(rt_dma_dev,RT_DEVICE_CTRL_DMA_REQUEST_CHANNEL,(void *)tx_trans);
if(ret != RT_EOK){
goto BIND_DMA_ERROR;
}
ret = rt_dma_dev->ops->control(rt_dma_dev,RT_DEVICE_CTRL_DMA_REQUEST_CHANNEL,(void *)rx_trans);
if(ret != RT_EOK){
//release tx channel...
rt_dma_dev->ops->control(rt_dma_dev,RT_DEVICE_CTRL_DMA_RELEASE_CHANNEL,(void *)&tx_trans);
goto BIND_DMA_ERROR;
}
//spi_control->xfer_mode = XFER_USE_DMA;
spi_control->dma.dma_flag = DMA_BIND_OK;
}
}
else{
BIND_DMA_ERROR:
spi_control->dma.dma_flag = DMA_BIND_ERROR;
//spi_control->xfer_mode = XFER_USE_ISR;
}
control_slave = &spi_control->spi_slave;
for(i=0;i<plat_data->slave_no;i++){
spi_slave = (struct spi_slave_info*)rt_malloc(sizeof(struct spi_slave_info));
if(!spi_slave){
rt_kprintf("ERROR:no mem for malloc the spi_slave%d..\n",i);
goto error_malloc_slave;
}
rt_memset(spi_slave, 0, sizeof(struct spi_slave_info));
//parse platform data...
spi_slave->id = i;
//bind to the spi control....will easy to find all the data...
spi_slave->control = spi_control;
spi_slave->plat_slave.cs_pin = plat_data->plat_slave[i].cs_pin;
spi_slave->plat_slave.actice_level = plat_data->plat_slave[i].actice_level;
rt_sprintf(spi_dev_name, "%s%d%s%d", "ssi", spi_control->id,"_",spi_slave->id);
*control_slave = spi_slave;
control_slave = &spi_slave->next;
//register slave dev...
ret = rt_spi_bus_attach_device(&spi_slave->spi_device,spi_dev_name,spi_bus_name,spi_slave);
if(ret != RT_EOK){
rt_kprintf("register dev to bus failed...\n");
goto error_malloc_slave;
}
}
//request gpio...
spi_slave = spi_control->spi_slave;
while(spi_slave != RT_NULL)
{
next_slave = spi_slave->next;
ret = gpio_request(spi_slave->plat_slave.cs_pin);
if(ret!=0){
rt_kprintf("request gpio_%d failed...\n",spi_slave->plat_slave.cs_pin);
goto error_malloc_slave;
}
PRINT_SPI_DBG("spi_slave info addr:%x,id:%d,cs:%d,active:%d\n",(rt_uint32_t)spi_slave, spi_slave->id,
spi_slave->plat_slave.cs_pin,
spi_slave->plat_slave.actice_level);
spi_slave = next_slave;
}
//this will be used in platform exit..
plat_data->control = spi_control;
return RT_EOK;
error_malloc_slave:
//free the slaveinfo already malloc
spi_slave = spi_control->spi_slave;
while(spi_slave != RT_NULL)
{
next_slave = spi_slave->next;
gpio_release(spi_slave->plat_slave.cs_pin);
rt_free(spi_slave);
spi_slave = next_slave;
}
//mask isr
rt_hw_interrupt_mask(spi_control->irq);
//release sem ..
rt_sem_detach(&spi_control->xfer_lock);
//free the control malloc .
rt_free(spi_control);
//fixme:unregister spi_bus...
error_malloc_bus:
return -RT_ENOMEM;
}
int fh_spi_exit(void *priv_data)
{
struct spi_controller *spi_control;
struct spi_control_platform_data *plat_data;
struct spi_slave_info *spi_slave;
struct spi_slave_info *next_slave;
plat_data = (struct spi_control_platform_data *)priv_data;
spi_control = plat_data->control;
spi_slave = spi_control->spi_slave;
while(spi_slave != RT_NULL)
{
next_slave = spi_slave->next;
gpio_release(spi_slave->plat_slave.cs_pin);
rt_free(spi_slave);
spi_slave = next_slave;
}
//mask isr
rt_hw_interrupt_mask(spi_control->irq);
//release sem ..
rt_sem_detach(&spi_control->xfer_lock);
//free the control malloc .
rt_free(spi_control);
//fixme free all the malloc data ...
return 0;
}
struct fh_board_ops spi_driver_ops =
{
.probe = fh_spi_probe,
.exit = fh_spi_exit,
};
void rt_hw_spi_init(void)
{
int ret;
// rt_kprintf("%s start\n", __func__);
PRINT_SPI_DBG("%s start\n", __func__);
fh_board_driver_register("spi", &spi_driver_ops);
PRINT_SPI_DBG("%s end\n", __func__);
//fixme: never release?
}
#if(0)
#define TEST_SPI_BUFF_SIZE 0x100
static rt_uint8_t tx_buf[TEST_SPI_BUFF_SIZE] = {0};
static rt_uint8_t rx_buf[TEST_SPI_BUFF_SIZE] = {0};
int ssi_test(void){
struct rt_spi_device * rt_spi_device;
int ret;
rt_spi_device = (struct rt_spi_device *)rt_device_find("ssi1_0");
if(rt_spi_device == RT_NULL)
{
rt_kprintf("%s spi device %s not found!\r\n",__func__ ,"ssi1_0");
return -RT_ENOSYS;
}
/* 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(rt_spi_device, &cfg);
}
rt_memset(tx_buf,0x55,TEST_SPI_BUFF_SIZE);
rt_spi_transfer(rt_spi_device,tx_buf,rx_buf,TEST_SPI_BUFF_SIZE);
ret = rt_memcmp(tx_buf,rx_buf,TEST_SPI_BUFF_SIZE);
if(ret != 0){
rt_kprintf("compare error ..error data %x\n",ret);
}
rt_kprintf("test done \n");
return 0;
}
#ifdef RT_USING_FINSH
#include <finsh.h>
FINSH_FUNCTION_EXPORT(ssi_test, fh_ssi_test);
#endif
#endif
View Git Blame Copy Permalink