基于linux的OLED移植过程

最新推荐文章于 2024-04-27 19:47:00 发布

yqj1123

最新推荐文章于 2024-04-27 19:47:00 发布

阅读量1.8k

点赞数

分类专栏： oled驱动文章标签： s3c6410 android kernel linux ssd1353

本文链接：https://blog.csdn.net/yqj1123/article/details/38821727

版权

oled驱动专栏收录该内容

1 篇文章 0 订阅

订阅专栏

作者：余黔江

硬件平台：S3C6410

软件环境：Linux2.3.6

文件系统：android2.3

一、移植前准备工作

1. 熟悉s3c6410的SPI驱动工作流程

2. 将s3c6410 SPI的TX与RX连接到一起，测试SPI是否正常

3. 在SPI正常的前提下，仔细阅读ssd1353芯片手册，尤其是上电时序部分

二、开始移植SPI总线驱动

1. 在mach-s3c64xx/mach-xxx6410.c中添加如下部分（我用的是SPI0，6410有两个SPI）

s3c64xx_spi_set_info(0,0,2);

spi_register_board_info(s3c6410_spi0_board,ARRAY_SIZE(s3c6410_spi0_board));

1.1． s3c64xx_spi_set_info(0,0,2);

该函数定义在dev-spi.c中

void __init s3c64xx_spi_set_info(int cntrlr, intsrc_clk_nr, int num_cs)

{

structs3c64xx_spi_info *pd;

/* Reject invalidconfiguration */

if (!num_cs ||src_clk_nr < 0

||src_clk_nr > S3C64XX_SPI_SRCCLK_48M) {

printk(KERN_ERR"%s: Invalid SPI configuration\n", __func__);

return;

}

switch (cntrlr) {

case 0:

pd = &s3c64xx_spi0_pdata;

break;

case 1:

pd =&s3c64xx_spi1_pdata;

break;

default:

printk(KERN_ERR"%s: Invalid SPI controller(%d)\n",

__func__,cntrlr);

return;

}

pd->num_cs =num_cs;

pd->src_clk_nr= src_clk_nr;

pd->src_clk_name= spi_src_clks[src_clk_nr];

}

其中static structs3c64xx_spi_info s3c64xx_spi0_pdata = {

.cfg_gpio =s3c64xx_spi_cfg_gpio,

.fifo_lvl_mask =0x7f,

.rx_lvl_offset =13,

};

static int s3c64xx_spi_cfg_gpio(struct platform_device*pdev)

{//此函数初始化SPI相关管脚

switch(pdev->id) {

case 0:

s3c_gpio_cfgpin(S3C64XX_GPC(0),S3C64XX_GPC0_SPI_MISO0);

s3c_gpio_cfgpin(S3C64XX_GPC(1),S3C64XX_GPC1_SPI_CLKO);

s3c_gpio_cfgpin(S3C64XX_GPC(2),S3C64XX_GPC2_SPI_MOSIO);

s3c_gpio_setpull(S3C64XX_GPC(0),S3C_GPIO_PULL_UP);

s3c_gpio_setpull(S3C64XX_GPC(1),S3C_GPIO_PULL_UP);

s3c_gpio_setpull(S3C64XX_GPC(2),S3C_GPIO_PULL_UP);

break;

case 1:

s3c_gpio_cfgpin(S3C64XX_GPC(4),S3C64XX_GPC4_SPI_MISO1);

s3c_gpio_cfgpin(S3C64XX_GPC(5),S3C64XX_GPC5_SPI_CLK1);

s3c_gpio_cfgpin(S3C64XX_GPC(6),S3C64XX_GPC6_SPI_MOSI1);

s3c_gpio_setpull(S3C64XX_GPC(4),S3C_GPIO_PULL_UP);

s3c_gpio_setpull(S3C64XX_GPC(5),S3C_GPIO_PULL_UP);

s3c_gpio_setpull(S3C64XX_GPC(6),S3C_GPIO_PULL_UP);

break;

default:

dev_err(&pdev->dev,"Invalid SPI Controller number!");

return-EINVAL;

}

return 0;

}

1.2． spi_register_board_info(s3c6410_spi0_board,ARRAY_SIZE(s3c6410_spi0_board));

s3c6410_spi0_board----->

static structspi_board_info s3c6410_spi0_board[] = {

[0] = {

.modalias = "spidev",

.bus_num= 0,

.chip_select= 0,

.irq =IRQ_SPI0,

.max_speed_hz= 1000000, //500*1000,

.mode=SPI_MODE_2,/* CPOL=1, CPHA=0 */

.controller_data=&s3c64xx_spi0_csinfo,

};

s3c64xx_spi0_csinfo----->

static voidcs_set_level(unsigned line_id, int lvl) {

gpio_direction_output(line_id, lvl);

}

static structs3c64xx_spi_csinfo s3c64xx_spi0_csinfo = {

.fb_delay=100,

.line=S3C64XX_GPC(3),

.set_level=cs_set_level,

};

spi_register_board_info----->在drivers/spi/spi.c中，将spi添加进入到链表中

int __init

spi_register_board_info(struct spi_board_infoconst *info, unsigned n)

{

structboardinfo *bi;

bi =kmalloc(sizeof(*bi) + n * sizeof*info, GFP_KERNEL);//注意观察此处分配大小的奥妙，牛人就是牛人，佩服！

if (!bi)

return-ENOMEM;

bi->n_board_info= n;

memcpy(bi->board_info,info, n * sizeof *info);

mutex_lock(&board_lock);

list_add_tail(&bi->list,&board_list);

mutex_unlock(&board_lock);

return0;

}

2. platform_add_devices(xxx6410_devices, ARRAY_SIZE(xxx6410_devices));中添加设备驱动

2.1. xxx6410_devices ----->

添加 &s3c64xx_device_spi0,

2.1.1 s3c64xx_device_spi0,------>

定义在dev-spi.c中

structplatform_device s3c64xx_device_spi0 = {

.name = "s3c64xx-spi",

.id = 0,

.num_resources =ARRAY_SIZE(s3c64xx_spi0_resource),

.resource =s3c64xx_spi0_resource,

.dev= {

.dma_mask = &spi_dmamask,

.coherent_dma_mask = DMA_BIT_MASK(32),

.platform_data= &s3c64xx_spi0_pdata,

};

static struct resource s3c64xx_spi0_resource[] = {

[0]= {

.start= S3C64XX_PA_SPI0,

.end = S3C64XX_PA_SPI0 + 0x100 - 1,

.flags= IORESOURCE_MEM,

[1]= {

.start= DMACH_SPI0_TX,

.end = DMACH_SPI0_TX,

.flags= IORESOURCE_DMA,

[2]= {

.start= DMACH_SPI0_RX,

.end = DMACH_SPI0_RX,

.flags= IORESOURCE_DMA,

[3]= {

.start= IRQ_SPI0,

.end = IRQ_SPI0,

.flags= IORESOURCE_IRQ,

};

-------> static struct s3c64xx_spi_info s3c64xx_spi0_pdata = {

.cfg_gpio =s3c64xx_spi_cfg_gpio,

.fifo_lvl_mask = 0x7f,

.rx_lvl_offset = 13,

};

3. spi总线注册以及spi_master的注册 drivers/spi/spi.c

4. s3c6410平台驱动注册drivers/spi/spi_s3c64xx.c

5. 设备驱动注册drivers/spi/spidev.c此部分是重点说明的部分

static int __init spidev_init(void)

{

int status;

/* Claim our256 reserved device numbers. Thenregister a class

* that will key udev/mdev to add/remove /devnodes. Last, register

* the driver which manages those devicenumbers.

BUILD_BUG_ON(N_SPI_MINORS> 256);

status =register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);

if (status <0)

returnstatus;

spidev_class = class_create(THIS_MODULE, "spidev");

if(IS_ERR(spidev_class)) {

unregister_chrdev(SPIDEV_MAJOR,spidev_spi_driver.driver.name);

returnPTR_ERR(spidev_class);

}

status = spi_register_driver(&spidev_spi_driver);

if (status <0) {

class_destroy(spidev_class);

unregister_chrdev(SPIDEV_MAJOR,spidev_spi_driver.driver.name);

}

return status;

}

module_init(spidev_init);

spidev_spi_driver------------------->

static structspi_driver spidev_spi_driver = {

.driver = {

.name = "spidev",

.owner = THIS_MODULE,

.probe = spidev_probe,

.remove = __devexit_p(spidev_remove),

};

static int__devinit spidev_probe(struct spi_device *spi)

{

struct spidev_data *spidev;

int status,err;

unsigned long minor;

/* Allocate driver data */

spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);//分配spidev数据空间

if (!spidev)

return -ENOMEM;

/* Initialize the driver data */

spidev->spi = spi;

spin_lock_init(&spidev->spi_lock);

mutex_init(&spidev->buf_lock);

INIT_LIST_HEAD(&spidev->device_entry);

/* If we can allocate a minor number, hookup 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(spidev_class, &spi->dev, spidev->devt,

spidev, "spidev%d.%d",

spi->master->bus_num,spi->chip_select);

//此处创建设备文件/dev/spidev0.0等文件

status = IS_ERR(dev) ? PTR_ERR(dev): 0;

//sysfs_create_group(&dev->kobj,&attr_group);

} else {

dev_dbg(&spi->dev, "nominor 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);

//writel(readl(S3C64XX_GPQCON) |S3C64XX_GPQ1_EINT_G9_1, S3C64XX_GPQCON);

//err = request_irq(188,FR_synchronization_irq_hander, IRQF_ONESHOT ,

// "oled_fr_sync",NULL);

//if (err < 0)

// printk("\n***********registerfr sync irq failed.\n");

oled_gpio_init(); //此处对SSD1353控制管脚进行初始化

return status;

}

spidev_fops -------->

static conststruct file_operations spidev_fops = {

.owner = THIS_MODULE,

/* REVISIT switch to aio primitives, sothat userspace

*gets more complete API coverage. It'llsimplify things

*too, except for the locking.

.write = spidev_write,

.read = spidev_read,

.unlocked_ioctl = spidev_ioctl,

.open = spidev_open,

.release = spidev_release,

};

static int spidev_open(struct inode*inode, struct file *filp)

{

struct spidev_data *spidev;

int status= -ENXIO;

mutex_lock(&device_list_lock);

list_for_each_entry(spidev,&device_list, device_entry) {

if (spidev->devt ==inode->i_rdev) {

status = 0;

break;

}

if (status == 0) {

if (!spidev->buffer) {

spidev->buffer= kmalloc(bufsiz, GFP_KERNEL);此处分配ram的缓冲区，故每次发送数据最大只能发送4096 byte

if (!spidev->buffer) {

dev_dbg(&spidev->spi->dev,"open/ENOMEM\n");

status = -ENOMEM;

}

if (status == 0) {

spidev->users++;

filp->private_data =spidev;

nonseekable_open(inode,filp);

}

} else

pr_debug("spidev: nothing forminor %d\n", iminor(inode));

mutex_unlock(&device_list_lock);

return status;

}

spidev_ioctl --------->

static long

spidev_ioctl(structfile *filp, unsigned int cmd, unsigned long arg)

{

。。。。。。

switch (cmd) {

/* read requests */

case SPI_IOC_RD_MODE:

retval = __put_user(spi->mode& SPI_MODE_MASK,

(__u8 __user*)arg);

break;

case SPI_IOC_RD_LSB_FIRST:

retval = __put_user((spi->mode& SPI_LSB_FIRST) ? 1 : 0,

(__u8 __user*)arg);

break;

case SPI_IOC_RD_BITS_PER_WORD:

retval =__put_user(spi->bits_per_word, (__u8 __user *)arg);

break;

case SPI_IOC_RD_MAX_SPEED_HZ:

retval =__put_user(spi->max_speed_hz, (__u32 __user *)arg);

break;

/* write requests */

case SPI_IOC_WR_MODE:

retval = __get_user(tmp, (u8 __user*)arg);

if (retval == 0) {

u8 save = spi->mode;

if (tmp & ~SPI_MODE_MASK){

retval = -EINVAL;

break;

}

tmp |= spi->mode &~SPI_MODE_MASK;

spi->mode = (u8)tmp;

retval = spi_setup(spi);

if (retval < 0)

spi->mode = save;

else

dev_dbg(&spi->dev,"spi mode %02x\n", tmp);

}

break;

case SPI_IOC_WR_LSB_FIRST:

retval = __get_user(tmp, (__u8__user *)arg);

if (retval == 0) {

u8 save = spi->mode;

if (tmp)

spi->mode |=SPI_LSB_FIRST;

else

spi->mode &=~SPI_LSB_FIRST;

retval = spi_setup(spi);

if (retval < 0)

spi->mode = save;

else

dev_dbg(&spi->dev,"%csb first\n",

tmp ?'l' : 'm');

}

break;

case SPI_IOC_WR_BITS_PER_WORD:

retval = __get_user(tmp, (__u8__user *)arg);

if (retval == 0) {

u8 save = spi->bits_per_word;

spi->bits_per_word = tmp;

retval = spi_setup(spi);

if (retval < 0)

spi->bits_per_word= save;

else

dev_dbg(&spi->dev,"%d bits per word\n", tmp);

}

break;

case SPI_IOC_WR_MAX_SPEED_HZ:

retval = __get_user(tmp, (__u32__user *)arg);

if (retval == 0) {

u32 save = spi->max_speed_hz;

spi->max_speed_hz = tmp;

retval = spi_setup(spi);

if (retval < 0)

spi->max_speed_hz =save;

else

dev_dbg(&spi->dev,"%d Hz (max)\n", tmp);

}

break;

case SPI_IOC_OLED_INIT:

SSD1353_initial(spidev);

retval = 0;

break;

case SPI_IOC_SET_CURSOR: