spi驱动初试，在linux下实现的spiflash驱动 - Firefly开源社区

static int flash_spi_probe(struct spi_device *spi)
{
struct spidev_data *spidev;
struct device_node *np = spi->dev.of_node; /*Get device tree node*/
int status;
unsigned long minor;
int ret;
printk("%s \n", __FUNCTION__);
/* Allocate driver data */
spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
if (!spidev)
return -ENOMEM;
/* Initialize the driver data */
spi->mode = 1;
spi->max_speed_hz = 1000 * 1000 *10;
spi->bits_per_word = 8;
spidev->spi = spi;
/*inin lock*/
spin_lock_init(&spidev->spi_lock);
mutex_init(&spidev->buf_lock);
/*Reset register condition*/
At45db_nrst = of_get_named_gpio(np, "At45db_nrst", 0);
ret = gpio_request(At45db_nrst, "At45db_nrst");
if (ret)
return -ENODEV;
gpio_direction_output(At45db_nrst, GPIO_LOW);
gpio_direction_output(At45db_nrst, GPIO_HIGH);
/*Turn off write protect*/
At45db_nwp = of_get_named_gpio(np, "At45db_nwp", 0);
ret = gpio_request(At45db_nwp, "At45db_nwp");
if (ret)
return -ENODEV;
//At45db_flash_init(spidev);
INIT_LIST_HEAD(&spidev->device_entry);
/* If we can allocate a minor number, hook up this device.
* Reusing minors is fine so long as udev or mdev is working.
*/
mutex_lock(&device_list_lock);
minor = find_first_zero_bit(minors, N_SPI_MINORS);
if (minor < N_SPI_MINORS) {
struct device *dev;
spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
dev = device_create(spiflash_cls, &spi->dev, spidev->devt,
spidev, "spidev%d.%d",
spi->master->bus_num, spi->chip_select);
status = PTR_RET(dev);
} else {
dev_dbg(&spi->dev, "no minor number available!\n");
status = -ENODEV;
}
if (status == 0) {
set_bit(minor, minors);
list_add(&spidev->device_entry, &device_list);
}
mutex_unlock(&device_list_lock);
if (status == 0)
spi_set_drvdata(spi, spidev);
else
kfree(spidev);
return status;
}

复制代码

和设备树匹配的代码，基本都是这个套路，匹配compatible就行了

复制代码

static inline ssize_t
spidev_sync_read(struct spidev_data *spidev, FLASH_C *flash_c)
{
struct spi_transfer t[] = {
{
.tx_buf = flash_c->cmd,
.len = flash_c->cmd_len,
},
{
.rx_buf = flash_c->read_buf,
.len = flash_c->read_buf_len,
}
};
struct spi_message m;
spi_message_init(&m);
spi_message_add_tail(&t[0], &m);
spi_message_add_tail(&t[1], &m);
return spidev_sync(spidev, &m);
}

复制代码

static ssize_t
spidev_sync(struct spidev_data *spidev, struct spi_message *message)
{
DECLARE_COMPLETION_ONSTACK(done);
int status;
#if 1
message->complete = spidev_complete;
message->context = &done;
#endif
spin_lock_irq(&spidev->spi_lock);
if (spidev->spi == NULL)
status = -ESHUTDOWN;
else
status = spi_async(spidev->spi, message);
spin_unlock_irq(&spidev->spi_lock);
if (status == 0) {
wait_for_completion(&done);
status = message->status;
if (status == 0)
status = message->actual_length;
}
return status;
}

复制代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <assert.h>
typedef struct TEST_Flash_Ctrl
{ unsigned char *cmd;
unsigned char *read_buf;
unsigned char *w_data;
unsigned char cmd_len;
unsigned char read_buf_len;
unsigned char w_len;
unsigned char resv;
}TEST_C;
static int fd;
static int write_to_flash(TEST_C *buf)
{
return write(fd, buf, sizeof(TEST_C));
}
static int read_from_flash(TEST_C *buf)
{
return read(fd, buf, buf->read_buf_len);
}
static int init_flash()
{
/*erase before write*/
int ret ;
TEST_C buf;
unsigned char erase_cmd[] = {0xc7, 0x94, 0x80, 0x9a};
buf.cmd = erase_cmd;
buf.cmd_len = sizeof(erase_cmd);
ret = write_to_flash(&buf);
if (0 == ret)
{
printf("%s: write err.\n ", __FUNCTION__);
return ret;
}
return 0;
}
static int write_buffer(unsigned short addr, unsigned char* data, unsigned char len)
{
unsigned char w_cmd[4];
unsigned char addr_u = (unsigned char)(addr >> 8);
unsigned char addr_v = (unsigned char)addr;
int ret;
TEST_C buf;
w_cmd[0] = 0x84;
w_cmd[1] = 0xff;
w_cmd[2] = addr_u;
w_cmd[3] = addr_v;
buf.cmd = w_cmd;
buf.cmd_len = sizeof(w_cmd);
buf.w_data = data;
buf.w_len = len;
ret = write_to_flash(&buf);
if (0 == ret)
{
printf("%s: write err.\n ", __FUNCTION__);
return ret;
}
return 0;
}
static int read_buffer(unsigned short add, unsigned char *read_buf, unsigned char len)
{
unsigned char r_cmd[5];
unsigned char addr_u;
unsigned char addr_v;
TEST_C test_c;
TEST_C buf;
addr_u = (unsigned char)(add >> 8);
addr_v = (unsigned char)add;
r_cmd[0] = 0xd4;
r_cmd[1] = 0xff;
r_cmd[2] = addr_u;
r_cmd[3] = addr_v;
r_cmd[4] = 0xff;
buf.cmd = r_cmd;
buf.cmd_len = sizeof(r_cmd);
buf.read_buf = read_buf;
buf.read_buf_len = len;
read_from_flash(&buf);
}
static unsigned char read_status()
{
TEST_C buf;
unsigned char cmd[1];
unsigned char status = 0;
printf("Get status \n");
cmd[0] = 0xd7;
buf.cmd = cmd;
buf.cmd_len = 1;
buf.read_buf = &status;
buf.read_buf_len = 1;
read_from_flash(&buf);
return status;
}
int main(void)
{
int ret = 0;
unsigned char buf_room[10];
unsigned char status;
unsigned short addr = 0x0;
unsigned char data[] = {0x00, 0xff, 0x0, 0xff, 0x0, 0xff};
fd = open("/dev/spidev0.0", O_RDWR);
if (fd < 0)
{
printf("%s open device failed. \n", __FUNCTION__);
return -1;
}
init_flash();
#if 1
write_buffer(addr, data, sizeof(data));
read_buffer(addr, buf_room, 8);
printf("Data is %x \n", buf_room[0]);
printf("Data is %x \n", buf_room[1]);
printf("Data is %x \n", buf_room[2]);
#endif
ret = close(fd);
return 0;
}

复制代码