基于xilinx平台的触摸屏驱动开发

最新推荐文章于 2024-04-03 18:43:06 发布
最新推荐文章于 2024-04-03 18:43:06 发布
阅读量185 收藏 1
点赞数
文章标签： 驱动开发 linux 物联网 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44470384/article/details/133701399
版权

1.dtsi配置

#include <dt-bindings/gpio/gpio.h>
#include <dt-bindings/pinctrl/pinctrl-zynqmp.h>

/include/ "system-conf.dtsi"
/ {
   model = "Zynq MpSoc Development Board";
   
   chosen {
   bootargs = "earlycon console=ttyPS0,115200 clk_ignore_unused root=/dev/mmcblk1p2 rw rootwait";
   stdout-path = "serial0:115200n8";
   };

   keypl {
   compatible = "alinx-keypl";
   key-gpios = <&gpio 38 GPIO_PULL_UP>;
  };
   
};



&amba_pl {
      axidmatest_0: axidmatest@0 {
              compatible ="xlnx,axi-dma-test-1.00.a";
              dmas = <&axi_dma_0 0 &axi_dma_0 1>;
              dma-names = "axidma0","axidma1";
      };    
};


/* SD */
&sdhci1 {
	disable-wp;
	no-1-8-v;
};

/* USB */
&dwc3_0 {
	status = "okay";
	dr_mode = "host";
};

&amba {
	zyxclmm_drm {
		compatible = "xlnx,zocl";
		status = "okay";
	};
};

&i2c0 {
	status = "okay";
	clock-frequency = <100000>;

	xilinx_an071@5D {	
		compatible = "goodix,gt9xx";
		reg = <0x5D>;
		interrupt-parent = <&gic>;
		interrupts = <0 91 4>;
	};
};

&v_tc_0 {
	compatible = "xlnx,bridge-v-tc-6.1";
	xlnx,pixels-per-clock = <1>;
};

&axi_dynclk_0 {
	compatible = "digilent,axi-dynclk";
	#clock-cells = <0x0>;			
	linux,phandle = <0xc>;
	phandle = <0xc>;
};


&amba {
	drm-pl-disp-drv {
		compatible = "xlnx,pl-disp";
		dmas = <&axi_vdma_0 0>;
		dma-names = "dma0";
		xlnx,vformat = "RG24";
		xlnx,bridge = <&v_tc_0>;

		port@0 {
			reg = <0>;
			pl_disp_crtc: endpoint {
				remote-endpoint = <&lcd_port>;
			};
		};
	}; 

	ax_lcd_encoder  {
		compatible = "ax-drm-encoder";
		ports {
			#address-cells = <1>;
			#size-cells = <0>;
			encoder_lcd_port: port@0 {
				reg = <0>;
				lcd_port: endpoint {
					remote-endpoint = <&pl_disp_crtc>;
				};
			};
		};
	};
};


&gpio {
	status = "okay";
};

2.驱动层

#include <linux/kernel.h>
#include <linux/hrtimer.h>
#include <linux/i2c.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/i2c.h>
#include <linux/proc_fs.h>
#include <linux/string.h>
#include <asm/uaccess.h>
#include <linux/vmalloc.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/gpio.h>
#include <linux/irq.h>
#include <linux/uaccess.h>

#define SCREEN_MAX_X                800
#define SCREEN_MAX_Y                480
//***************************PART1:ON/OFF define*******************************
#define GTP_DEBUG_ON          1
#define GTP_DEBUG_FUNC_ON     0

struct goodix_ts_data {
    spinlock_t irq_lock;
    struct i2c_client *client;
    struct input_dev  *input_dev;
    struct hrtimer timer;
    struct work_struct  work;
    s32 irq_is_disable;
    s32 use_irq;
    u16 abs_x_max;
    u16 abs_y_max;
    u8  int_trigger_type;

    u8  gtp_rawdiff_mode;
};

//*************************** PART2:TODO define **********************************
#define GTP_MAX_HEIGHT   800
#define GTP_MAX_WIDTH    480
#define GTP_INT_TRIGGER  0            // 0: Rising 1: Falling
#define GTP_MAX_TOUCH         1
//***************************PART3:OTHER define*********************************
#define GTP_DRIVER_VERSION          "V2.4<2014/11/28>"
#define GTP_I2C_NAME                "goodix,gt9xx"
#define GTP_POLL_TIME         10    
#define GTP_ADDR_LENGTH       2
#define GTP_CONFIG_MIN_LENGTH 186
#define GTP_CONFIG_MAX_LENGTH 240
#define FAIL                  0
#define SUCCESS               1
#define SWITCH_OFF            0
#define SWITCH_ON             1

// Registers define
#define GTP_READ_COOR_ADDR    0x814E
#define GTP_REG_SLEEP         0x8040
#define GTP_REG_SENSOR_ID     0x814A
#define GTP_REG_CONFIG_DATA   0x8047
#define GTP_REG_VERSION       0x8140

#define RESOLUTION_LOC        3
#define TRIGGER_LOC           8

// Log define
#define GTP_INFO(fmt,arg...)           printk("<<-GTP-INFO->> "fmt"\n",##arg)
#define GTP_ERROR(fmt,arg...)          printk("<<-GTP-ERROR->> "fmt"\n",##arg)
#define GTP_DEBUG(fmt,arg...)          do{\
                                         if(GTP_DEBUG_ON)\
                                         printk("<<-GTP-DEBUG->> [%d]"fmt"\n",__LINE__, ##arg);\
                                       }while(0)

#define GTP_DEBUG_FUNC()               do{\
                                         if(GTP_DEBUG_FUNC_ON)\
                                         printk("<<-GTP-FUNC->> Func:%s@Line:%d\n",__func__,__LINE__);\
                                       }while(0)

static const char *goodix_ts_name = "goodix-ts";
//static const char *goodix_input_phys = "input/ts";
static struct workqueue_struct *goodix_wq;
struct i2c_client * i2c_connect_client = NULL; 

u8 config[GTP_CONFIG_MAX_LENGTH + GTP_ADDR_LENGTH]
                = {GTP_REG_CONFIG_DATA >> 8, GTP_REG_CONFIG_DATA & 0xff};

static s8 gtp_i2c_test(struct i2c_client *client);

struct edt_i2c_chip_data 
{
    int  max_support_points;
};

s32 gtp_i2c_read(struct i2c_client *client, u8 *buf, s32 len)
{
    struct i2c_msg msgs[2];
    s32 ret=-1;
    s32 retries = 0;

    GTP_DEBUG_FUNC();

    msgs[0].flags = !I2C_M_RD;
    msgs[0].addr  = client->addr;
    msgs[0].len   = GTP_ADDR_LENGTH;
    msgs[0].buf   = &buf[0];
    
    msgs[1].flags = I2C_M_RD;
    msgs[1].addr  = client->addr;
    msgs[1].len   = len - GTP_ADDR_LENGTH;
    msgs[1].buf   = &buf[GTP_ADDR_LENGTH];

    while(retries < 5)
    {
        ret = i2c_transfer(client->adapter, msgs, 2);
        if(ret == 2)break;
        retries++;
    }
    if((retries >= 5))
    {
        GTP_ERROR("I2C Read: 0x%04X, %d bytes failed, errcode: %d! Process reset.", (((u16)(buf[0] << 8)) | buf[1]), len-2, ret);
    }
    return ret;
}

s32 gtp_i2c_write(struct i2c_client *client,u8 *buf,s32 len)
{
    struct i2c_msg msg;
    s32 ret = -1;
    s32 retries = 0;

    GTP_DEBUG_FUNC();

    msg.flags = !I2C_M_RD;
    msg.addr  = client->addr;
    msg.len   = len;
    msg.buf   = buf;
    //msg.scl_rate = 300 * 1000;    // for Rockchip, etc

    while(retries < 5)
    {
        ret = i2c_transfer(client->adapter, &msg, 1);
        if (ret == 1)break;
        retries++;
    }
    if((retries >= 5))
    {
        GTP_ERROR("I2C Write: 0x%04X, %d bytes failed, errcode: %d! Process reset.", (((u16)(buf[0] << 8)) | buf[1]), len-2, ret);
    }
    return ret;
}

void gtp_irq_disable(struct goodix_ts_data *ts)
{
    unsigned long irqflags;

    GTP_DEBUG_FUNC();

    spin_lock_irqsave(&ts->irq_lock, irqflags);
    if (!ts->irq_is_disable)
    {
        ts->irq_is_disable = 1; 
        disable_irq_nosync(ts->client->irq);
    }
    spin_unlock_irqrestore(&ts->irq_lock, irqflags);
}

void gtp_irq_enable(struct goodix_ts_data *ts)
{
    unsigned long irqflags = 0;

    GTP_DEBUG_FUNC();
    
    spin_lock_irqsave(&ts->irq_lock, irqflags);
    if (ts->irq_is_disable) 
    {
        enable_irq(ts->client->irq);
        ts->irq_is_disable = 0; 
    }
    spin_unlock_irqrestore(&ts->irq_lock, irqflags);
}

static void gtp_touch_down(struct goodix_ts_data* ts,s32 id,s32 x,s32 y,s32 w)
{
    input_report_abs(ts->input_dev, ABS_X, x);
    input_report_abs(ts->input_dev, ABS_Y, y);
    input_report_abs(ts->input_dev, ABS_PRESSURE, w);

    input_report_abs(ts->input_dev, ABS_MT_POSITION_X, x);
    input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, y);
    input_report_abs(ts->input_dev, ABS_MT_PRESSURE, w);

    input_report_key(ts->input_dev, BTN_TOUCH, 1);

    input_mt_slot(ts->input_dev, id);
    input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, 1);

    GTP_DEBUG("touch_down ID:%d, X:%d, Y:%d, P:%d", id, x, y, w);
}

static void gtp_touch_up(struct goodix_ts_data* ts, s32 id,s32 x,s32 y,s32 w)
{
    input_report_abs(ts->input_dev, ABS_X, x);
    input_report_abs(ts->input_dev, ABS_Y, y);
    input_report_abs(ts->input_dev, ABS_PRESSURE, 0);

    input_report_abs(ts->input_dev, ABS_MT_POSITION_X, x);
    input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, y);
    input_report_abs(ts->input_dev, ABS_MT_PRESSURE, 0);

    input_report_key(ts->input_dev, BTN_TOUCH, 0);

    input_mt_slot(ts->input_dev, id);
    input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, 0);

    GTP_DEBUG("touch_up ID:%d, X:%d, Y:%d, P:%d", id, x, y, w);
}

static void goodix_ts_work_func(struct work_struct *work)
{
    u8  end_cmd[3] = {GTP_READ_COOR_ADDR >> 8, GTP_READ_COOR_ADDR & 0xFF, 0};
    u8  point_data[2 + 1 + 8 * GTP_MAX_TOUCH + 1]={GTP_READ_COOR_ADDR >> 8, GTP_READ_COOR_ADDR & 0xFF};
    u8  touch_num = 0;
    u8  finger = 0;
    static u16 pre_touch = 0;

    u8* coor_data = NULL;
    s32 input_x = 0;
    s32 input_y = 0;
    s32 input_w = 0;
    s32 id = 0;
    s32 i  = 0;
    s32 ret = -1;
    struct goodix_ts_data *ts = NULL;

    GTP_DEBUG_FUNC();
    ts = container_of(work, struct goodix_ts_data, work);

    ret = gtp_i2c_read(ts->client, point_data, 12);
    if (ret < 0)
    {
        GTP_ERROR("I2C transfer error. errno:%d\n ", ret);
        if (ts->use_irq)
        {
            gtp_irq_enable(ts);
        }
        return;
    }
    
    finger = point_data[GTP_ADDR_LENGTH];

    if (finger == 0x00)
    {
        if (ts->use_irq)
        {
            gtp_irq_enable(ts);
        }
        return;
    }

    if((finger & 0x80) == 0)
    {
        goto exit_work_func;
    }

    touch_num = finger & 0x0f;
    if (touch_num > GTP_MAX_TOUCH)
    {
        goto exit_work_func;
    }

    if (touch_num > 1)
    {
        u8 buf[8 * GTP_MAX_TOUCH] = {(GTP_READ_COOR_ADDR + 10) >> 8, (GTP_READ_COOR_ADDR + 10) & 0xff};

        ret = gtp_i2c_read(ts->client, buf, 2 + 8 * (touch_num - 1)); 
        memcpy(&point_data[12], &buf[2], 8 * (touch_num - 1));
    }

    if (touch_num == pre_touch)
    {
        for (i = 0; i < touch_num; i++)
        {
            coor_data = &point_data[i * 8 + 3];

            id = coor_data[0] & 0x0F;
            input_x  = coor_data[1] | (coor_data[2] << 8);
            input_y  = coor_data[3] | (coor_data[4] << 8);
            input_w  = coor_data[5] | (coor_data[6] << 8);
            gtp_touch_down(ts, id, input_x, input_y, input_w);
        }
    }
    else if (pre_touch)
    {
        for (i = 0; i < pre_touch; i++)
        {
            coor_data = &point_data[i * 8 + 3];

            id = coor_data[0] & 0x0F;
            input_x  = coor_data[1] | (coor_data[2] << 8);
            input_y  = coor_data[3] | (coor_data[4] << 8);
            input_w  = coor_data[5] | (coor_data[6] << 8);
            gtp_touch_up(ts, id, input_x, input_y, input_w);
        }
    }

    pre_touch = touch_num;
    
    input_mt_report_pointer_emulation(ts->input_dev, 1);
    input_sync(ts->input_dev);

exit_work_func:
    if(!ts->gtp_rawdiff_mode)
    {
        ret = gtp_i2c_write(ts->client, end_cmd, 3);
        if (ret < 0)
        {
            GTP_INFO("I2C write end_cmd error!");
        }
    }
    if (ts->use_irq)
    {
        gtp_irq_enable(ts);
    }
}

static enum hrtimer_restart goodix_ts_timer_handler(struct hrtimer *timer)
{
    struct goodix_ts_data *ts = container_of(timer, struct goodix_ts_data, timer);

    GTP_DEBUG_FUNC();

    queue_work(goodix_wq, &ts->work);
    hrtimer_start(&ts->timer, ktime_set(0, (GTP_POLL_TIME+6)*1000000), HRTIMER_MODE_REL);
    return HRTIMER_NORESTART;
}

static irqreturn_t goodix_ts_irq_handler(int irq, void *dev_id)
{
    struct goodix_ts_data *ts = dev_id;

    GTP_DEBUG_FUNC();
 
    gtp_irq_disable(ts);

    queue_work(goodix_wq, &ts->work);
    
    return IRQ_HANDLED;
}

static s32 gtp_init_panel(struct goodix_ts_data *ts)
{ 
    if ((ts->abs_x_max == 0) && (ts->abs_y_max == 0))
    {
        ts->abs_x_max = (config[RESOLUTION_LOC + 1] << 8) + config[RESOLUTION_LOC];
        ts->abs_y_max = (config[RESOLUTION_LOC + 3] << 8) + config[RESOLUTION_LOC + 2];
        ts->int_trigger_type = (config[TRIGGER_LOC]) & 0x03; 
    }

    GTP_INFO("X_MAX: %d, Y_MAX: %d, TRIGGER: 0x%02x", ts->abs_x_max,ts->abs_y_max,ts->int_trigger_type);

    msleep(10);
    return 0;
}

s32 gtp_read_version(struct i2c_client *client, u16* version)
{
    s32 ret = -1;
    u8 buf[8] = {GTP_REG_VERSION >> 8, GTP_REG_VERSION & 0xff};

    GTP_DEBUG_FUNC();

    ret = gtp_i2c_read(client, buf, sizeof(buf));
    if (ret < 0)
    {
        GTP_ERROR("GTP read version failed");
        return ret;
    }

    if (version)
    {
        *version = (buf[7] << 8) | buf[6];
    }
    if (buf[5] == 0x00)
    {
        GTP_INFO("IC Version: %c%c%c_%02x%02x", buf[2], buf[3], buf[4], buf[7], buf[6]);
    }
    else
    {
        GTP_INFO("IC Version: %c%c%c%c_%02x%02x", buf[2], buf[3], buf[4], buf[5], buf[7], buf[6]);
    }
    return ret;
}

static s8 gtp_i2c_test(struct i2c_client *client)
{
    u8 test[3] = {GTP_REG_CONFIG_DATA >> 8, GTP_REG_CONFIG_DATA & 0xff};
    u8 retry = 0;
    s8 ret = -1;
  
    GTP_DEBUG_FUNC();
  
    while(retry++ < 5)
    {
        ret = gtp_i2c_read(client, test, 3);
        if (ret > 0)
        {
            return ret;
        }
        GTP_ERROR("GTP i2c test failed time %d.",retry);
        msleep(10);
    }
    return ret;
}

static s8 gtp_request_irq(struct goodix_ts_data *ts)
{
    s32 ret = -1;
    unsigned long irq_flags;

    GTP_DEBUG_FUNC();
    GTP_DEBUG("INT trigger type:%x", ts->int_trigger_type);
    
    irq_flags = irq_get_trigger_type(ts->client->irq);
    if (irq_flags == IRQF_TRIGGER_NONE) irq_flags = IRQF_TRIGGER_HIGH;
    irq_flags |= IRQF_ONESHOT;
    
    ret = devm_request_threaded_irq(&ts->client->dev, ts->client->irq, NULL, goodix_ts_irq_handler, irq_flags, ts->client->name, ts);
    if (ret) 
    {
        GTP_ERROR("Request IRQ failed!ERRNO:%d.", ret);
        
        hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
        ts->timer.function = goodix_ts_timer_handler;
        hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
        return -1;
    }
    else 
    {
        gtp_irq_disable(ts);
        ts->use_irq = 1;
        return 0;
    }
}

static s8 gtp_request_input_dev(struct goodix_ts_data *ts)
{
    s8 ret = -1;
    s32 error = 0;
    
    GTP_DEBUG_FUNC();
  
    ts->input_dev = input_allocate_device();
    if (ts->input_dev == NULL)
    {
        GTP_ERROR("Failed to allocate input device.");
        return -ENOMEM;
    }

    __set_bit(EV_ABS, ts->input_dev->evbit);
    __set_bit(EV_KEY, ts->input_dev->evbit);
    __set_bit(EV_SYN, ts->input_dev->evbit);  
    __set_bit(BTN_TOUCH, ts->input_dev->keybit);

    input_set_abs_params(ts->input_dev, ABS_X, 0, SCREEN_MAX_X, 0, 0);
    input_set_abs_params(ts->input_dev, ABS_Y, 0, SCREEN_MAX_Y, 0, 0);
    input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 32, 0, 0);

    input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, SCREEN_MAX_X, 0, 0);
    input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, SCREEN_MAX_Y, 0, 0);
    input_set_abs_params(ts->input_dev, ABS_MT_PRESSURE, 0, 32, 0, 0);
  
    ts->input_dev->name = goodix_ts_name;
    ts->input_dev->id.bustype = BUS_I2C;
    ts->input_dev->dev.parent = &ts->client->dev;

    error = input_mt_init_slots(ts->input_dev, GTP_MAX_TOUCH, INPUT_MT_DIRECT);
    if (error) {
        GTP_ERROR("Failed to initialize MT slots: %d", error);
        return error;
    }
    
    ret = input_register_device(ts->input_dev);
    if (ret)
    {
        GTP_ERROR("Register %s input device failed", ts->input_dev->name);
        return -ENODEV;
    }

    return 0;
}

static int goodix_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
    s32 ret = -1;
    struct goodix_ts_data *ts;
    u16 version_info;
    
    GTP_DEBUG_FUNC();
    
    GTP_INFO("GTP Driver Version: %s", GTP_DRIVER_VERSION);
    GTP_INFO("GTP I2C Address: 0x%02x", client->addr);

    i2c_connect_client = client;
    
    if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) 
    {
        GTP_ERROR("I2C check functionality failed.");
        return -ENODEV;
    }
    ts = kzalloc(sizeof(*ts), GFP_KERNEL);
    if (ts == NULL)
    {
        GTP_ERROR("Alloc GFP_KERNEL memory failed.");
        return -ENOMEM;
    }

    INIT_WORK(&ts->work, goodix_ts_work_func);
    ts->client = client;
    spin_lock_init(&ts->irq_lock);

    i2c_set_clientdata(client, ts);   
    ts->gtp_rawdiff_mode = 0;

    ret = gtp_i2c_test(client);
    if (ret < 0)
    {
        GTP_ERROR("I2C communication ERROR!");
    }

    ret = gtp_read_version(client, &version_info);
    if (ret < 0)
    {
        GTP_ERROR("Read version failed.");
    }
    
    ret = gtp_init_panel(ts);
    if (ret < 0)
    {
        GTP_ERROR("GTP init panel failed.");
        ts->abs_x_max = GTP_MAX_WIDTH;
        ts->abs_y_max = GTP_MAX_HEIGHT;
        ts->int_trigger_type = GTP_INT_TRIGGER;
    }
 
    ret = gtp_request_input_dev(ts);
    if (ret < 0)
    {
        GTP_ERROR("GTP request input dev failed");
    }
    
    ret = gtp_request_irq(ts); 
    if (ret < 0)
    {
        GTP_INFO("GTP works in polling mode.");
    }
    else
    {
        GTP_INFO("GTP works in interrupt mode.");
    }

    if (ts->use_irq)
    {
        gtp_irq_enable(ts);
    }
    
    return 0;
}

static int goodix_ts_remove(struct i2c_client *client)
{
    struct goodix_ts_data *ts = i2c_get_clientdata(client);
    
    GTP_DEBUG_FUNC();

    if (ts) 
    {
        if (ts->use_irq)
        {
            //free_irq(client->irq, ts);
        }
        else
        {
            hrtimer_cancel(&ts->timer);
        }
    }   
    
    GTP_INFO("GTP driver removing...");
    i2c_set_clientdata(client, NULL);
    input_unregister_device(ts->input_dev);
    kfree(ts);

    return 0;
}

static int __maybe_unused alinx_ts_suspend(struct device *dev)
{
    struct i2c_client *client = to_i2c_client(dev);

    if (device_may_wakeup(dev)) enable_irq_wake(client->irq);

    return 0;
}

static int __maybe_unused alinx_ts_resume(struct device *dev)
{
    struct i2c_client *client = to_i2c_client(dev);

    if (device_may_wakeup(dev)) disable_irq_wake(client->irq);

    return 0;
}

static SIMPLE_DEV_PM_OPS(alinx_ts_pm_ops, alinx_ts_suspend, alinx_ts_resume);

static const struct edt_i2c_chip_data alinx_data = 
{
    .max_support_points = 5,
};


static const struct of_device_id goodix_match_table[] = {
		{.compatible = GTP_I2C_NAME, .data = &alinx_data },
		{ },
};

static const struct i2c_device_id goodix_ts_id[] = {
    { .name = GTP_I2C_NAME, .driver_data = (long)&alinx_data },
    { }
};

static struct i2c_driver goodix_ts_driver = {
    .probe      = goodix_ts_probe,
    .remove     = goodix_ts_remove,
    .id_table   = goodix_ts_id,
    .driver = {
        .name     = GTP_I2C_NAME,
        .owner    = THIS_MODULE,
        .of_match_table = goodix_match_table,
        .pm       = &alinx_ts_pm_ops,
    },
};

static int goodix_ts_init(void)
{
    s32 ret;

    GTP_DEBUG_FUNC();   
    GTP_INFO("GTP driver installing...");
    goodix_wq = create_singlethread_workqueue("goodix_wq");
    if (!goodix_wq)
    {
        GTP_ERROR("Creat workqueue failed.");
        return -ENOMEM;
    }

    ret = i2c_add_driver(&goodix_ts_driver);
    return ret; 
}

static void __exit goodix_ts_exit(void)
{
    GTP_DEBUG_FUNC();
    GTP_INFO("GTP driver exited.");
    i2c_del_driver(&goodix_ts_driver);
    if (goodix_wq)
    {
        destroy_workqueue(goodix_wq);
    }
}

module_init(goodix_ts_init);
module_exit(goodix_ts_exit);

MODULE_DESCRIPTION("GTP Series Driver");
MODULE_LICENSE("GPL");

交叉编译Makefile

modname:=touch_screen
obj-m:=$(modname).o

PWD :=$(shell pwd)
MAKE :=make
KERNELDIR = /home/petalinux/build/tmp/work-shared/zynqmp-generic/kernel-build-artifacts
CROSS_COMPILE=aarch64-linux-gnu-
ARCH=arm64


all:
	$(MAKE) ARCH=$(ARCH) CROSS_COMPILE=$(CROSS_COMPILE) -C $(KERNELDIR) M=$(PWD) modules

clean:
	rm -rf $(modname).ko *.o *mod* \.*cmd *odule* .tmp_versions


.PHONY: all clean

麦德泽特
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
v4l2+drm+dmabuf实现零拷贝视频环回功能
09-17
本人用的平台是xilinx, zynqMP，提供的资源是参考的源码，可以实现在一块板子上面自动播放视频。 HDMI v4l2进， HDMI DRM出 刚好在做音视频相关的工作，其他资源会在这段时间上传吧。赚点资源分去下载其他人资源。。。
linux kernel基本构成的内容有下列哪些项_Linux_GUI加速(2)_Linux中的DRM-KMS分析
weixin_39636099的博客
11-12 201
在上一小节《Linux GUI加速(1)_GUI系统概述》中，我们从应用层到kernel层大致分析了linux中的图形界面的构成，并在最后给出了kernel中DRM+KMS的软件显示框架以及accelerate logic+framebuffer+displayport的硬件结构。在这一子篇会将这两块内容详细展开。本篇主要以Xilinx的xc7z010 的SOPC（zybo的开发板）为硬件平台，在...
Xilinx ZC706 ADV7511使用
黑客三遍猪
07-24 5777
参考 Linux with HDMI video output on the ZED, ZC702 and ZC706 boards ADV7511 Xilinx Evaluation Boards Reference Design Zynq & Altera SoC Quick Start Guide analogdevicesinc/hdl analogdevicesinc/linu...
xilinx zynqmp HDMI tx代码解析剥离drm框架
最新发布
qq_43467135的博客
04-03 308
在1080p底分辨率时能通过arm端控制mix ip融合之后输出1080p的rgb数据，fpga在通过verilog或硬件驱动芯片完成视频数据的搬运，但当显示数据分辨率到达3840x2160之后，上述方法无法实现SDI和HDMI同显的功能需求，需要使用12G SDI和HDMI 2.0的IP实现，由于在xilinx驱动中只能实现单路接口显示，无法实现同显功能，需要从HDMI和SDI中剥离drm接口驱动，完成显示。3、probe函数中定义了xlnx_drm_hdmi结构体，先了解其成员变量。
xilinx平台dma分析
cesar的博客
07-11 5263
linux内核皆使用dmaengine架构来管理dma，未了解的可通过以下链接熟悉下： https://blog.csdn.net/were0415/article/details/54095899 现以视频输出为例进一步分析： 1.FPGA分配了一个显存空间，如下设备树所示： VideoOut_1ch_v_frmbuf_rd_0: v_frmbuf_rd@b0000000 { ...
xilinx低延时视频编解码方案
mkelehk的专栏
09-18 8003
xilinx的Zynq® UltraScale+™ MPSoCs（EV系列，ZCU106开发板）有一个视频编解码硬核VCU，能实现多种profile/level的H264/H265编解码能力，最高支持一路3840x2160@60或4096x2160@60 yuv422的分辨率，支持yuv422 10 bit HDR等，详细请参考《PG252》文档。 总共支持4种不同延时的编解码能力： VCU的软件框架使用了Gstreamer跨平台多媒体处理框架，可...
Linux驱动开发之DRM驱动
黑客三遍猪
08-05 8670
参考 DRM 驱动程序开发（开篇） drm 驱动是如何创建 fb device 的 Linux中的DRM 介绍 Linux Graphic DRI 显示子系统 介绍1 Xilinx DRM KMS driver
赛灵思xilinx平台drm分析
cesar的博客
06-26 5772
不管什么设备输出，使用drm框架，都要做几个步骤：fb、crtc、plane、encoder和connector初始化； 以xilinx异构平台设计在FPGA端的HDMI为例，跟读代码分析： 1.HDMI驱动模块 这里涉及到就是encoder和connector的初始化： static int xlnx_drm_hdmi_bind(struct device *dev, struct d...
Zynq移植USB触摸屏
超级虫虫的专栏
08-07 2067
Zynq平台移植USB触摸屏的实现（Qt5.7） 使用的环境： 1. CPU type：ARM CortexA9（Xilinx zynq7000）（使用的是黑金AX7021开发板） 2. Kernel version：4.9 3. no X-window, GUI system：QT5.7 4. Controller Interface：USB（EETI的EIR4000--eGalax，USB转接板ETP-RAP4502-E） 5. Controller Type：Resistive（...
基于Xilinx平台的嵌入式软件开发流程
06-02
基于Xilinx平台的嵌入式软件开发流程 在过去的Linux内核源码中，存在大量对板级细节信息描述的代码。这些代码充斥在/arch/arm/plat-xxx和/arch/arm/mach-xxx目录，对内核而言这些 platform设备、resource、i2c_board...
drm架构解析
09-10
改文档详细解释了linux显卡驱动drm架构的结构，对各个子模块进行了比较详细的分析，如modesetting，内存管理，drm_helper等。值得参考，内容清晰
drm示例代码
04-10
DRM是linux下的显示驱动代码架构，驱动代码位于drivers/gpu/drm，这个是应用层操作drm的示例代码。
XILINX与东京电子推出可编程开发平台
01-19
基于Spartan-3EFPGA的平台可以让开发者快速设计和验证范围广范的显示器产品 东京电子器件有限公司(TED)与赛灵思公司(NASDAQ:XLNX)宣布推出一款可实现的显示器应用（如平板电视机监视器和显示器、背投电视机和数字...
基于Xilinx FPGA的OFDM通信系统基带设计
04-17
基于Xilinx FPGA的OFDM通信系统基带设计
Xilinx和AXIS近日联合推出CDRS开发平台CDRSX
11-30
赛灵思公司(Xilinx, Inc.)和AXIS网络科技公司近日联合推出通用数字射频系统(CDRS)开发平台CDRSX。该平台可以提高W-CDMA和WiMAX基站的功率放大器(PA)效率并降低其资本支出和运营成本。CDRSX开发平台包括了赛灵思公司...
基于xilinx平台的DDR2控制器设计
02-21
基于FPGA的xilinx平台的DDR2控制器设计，这是个用户接口的工程，便于开发。
ZYNQ --- Linux成长之路 --- LCD显示屏（2）
qq_41121877的博客
11-13 487
承接上文，完成触摸屏驱动，以下代码在上一篇文章中添加内容即可。参考文章：《3_领航者之嵌入式Linux开发指南_V2.2》---第51章触摸屏驱动实验。
Linux DRM 相关知识
Hedia Pan的博客
01-18 1478
一、X Server 和 X Cilent 1.X server：负责软硬件的管理，将输入的软硬件事件通过一定协议转发给X client，将输出的图形绘制在屏幕上。包括键盘、鼠标、手写板、显示器 （monitor） 、屏幕分辨率与色彩深度、显卡 （包含驱动程序） 与显示的字体等等，都是 X Server 管理的。 2.X client：每个需要涉及到GUI的App，可以实例化为一个X client，X client主要是响应X server分发下来的事件，通过处理后，将待绘制的图像回传给X Server
xilinx fpga开发平台有哪些
09-02
Xilinx FPGA（现场可编程门阵列）开发平台提供了多个选择，以下是一些常见的平台： 1. Vivado Design Suite：这是Xilinx的主要设计工具套件，提供了全面的设计、验证和实现工具，支持从设计到部署的完整 FPGA 开发...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值