6410之AD驱动与触摸屏共存（下）

最新推荐文章于 2024-01-04 12:00:51 发布
最新推荐文章于 2024-01-04 12:00:51 发布
阅读量1.5k 收藏 1
点赞数 1
分类专栏： linux 6410驱动 文章标签： input struct c timer report module
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jingzhesiye/article/details/7895404
版权
该博客详细介绍了在S3C平台上如何实现触摸屏驱动与ADC驱动共存，包括ADC控制器的锁定机制、中断处理函数以及定时器功能，确保在不同操作间正确切换和数据采集。
摘要由CSDN通过智能技术生成 
触摸屏驱动源码
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/init.h>
#include <linux/serio.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/clk.h>

#include <asm/io.h>
#include <asm/irq.h>
#include <mach/hardware.h>

#include <plat/regs-adc.h>
#include <mach/ts.h>
#include <mach/irqs.h>

#define CONFIG_TOUCHSCREEN_S3C_DEBUG
#undef CONFIG_TOUCHSCREEN_S3C_DEBUG

/* For ts->dev.id.version */
#define S3C_TSVERSION	0x0101

#define WAIT4INT(x)  (((x)<<8) | \
		     S3C_ADCTSC_YM_SEN | S3C_ADCTSC_YP_SEN | S3C_ADCTSC_XP_SEN | \
		     S3C_ADCTSC_XY_PST(3))

#define AUTOPST	     (S3C_ADCTSC_YM_SEN | S3C_ADCTSC_YP_SEN | S3C_ADCTSC_XP_SEN | \
		     S3C_ADCTSC_AUTO_PST | S3C_ADCTSC_XY_PST(0))


#define DEBUG_LVL    KERN_DEBUG


/* Touchscreen default configuration */
struct s3c_ts_mach_info s3c_ts_default_cfg __initdata = {
                .delay = 		5000,//10000,
                .presc = 		49,
                .oversampling_shift = 	4,//2,
		.resol_bit = 		10
};

/*
 * Definitions & global arrays.
 */
static char *s3c_ts_name = "S3C TouchScreen";
static void __iomem 		*ts_base;
static struct resource		*ts_mem;
static struct resource		*ts_irq;
static struct clk		*ts_clock;
static struct s3c_ts_info 	*ts;

static int downflag=0;

static void touch_timer_fire(unsigned long data)
{
	unsigned long data0;
	unsigned long data1;
	int updown;

	data0 = readl(ts_base+S3C_ADCDAT0);
	data1 = readl(ts_base+S3C_ADCDAT1);

	updown = (!(data0 & S3C_ADCDAT0_UPDOWN)) && (!(data1 & S3C_ADCDAT1_UPDOWN));

	if (updown) {
		//printk("updown=1.\n");
		if (ts->count) {

#ifdef CONFIG_TOUCHSCREEN_S3C_DEBUG
			{
				struct timeval tv;
				do_gettimeofday(&tv);
				printk(KERN_INFO "T: %06d, X: %03ld, Y: %03ld\n", (int)tv.tv_usec, ts->xp, ts->yp);
			}
#endif
		    if(downflag==0)
                     {
			input_report_abs(ts->dev, ABS_X, ts->xp);
			input_report_abs(ts->dev, ABS_Y, ts->yp);

			input_report_key(ts->dev, BTN_TOUCH, 1);
			input_report_abs(ts->dev, ABS_PRESSURE, 1);
			input_sync(ts->dev);
                     }
                    else
                    {
                       // printk("downflag=1.ignore this data.\n");
		    	downflag=0;
                    }
		}

		ts->xp = 0;
		ts->yp = 0;
		ts->count = 0;

		writel(S3C_ADCTSC_PULL_UP_DISABLE | AUTOPST, ts_base+S3C_ADCTSC);
		writel(readl(ts_base+S3C_ADCCON) | S3C_ADCCON_ENABLE_START, ts_base+S3C_ADCCON);
	}
	else {

		ts->count = 0;

		input_report_key(ts->dev, BTN_TOUCH, 0);
		input_report_abs(ts->dev, ABS_PRESSURE, 0);
		input_sync(ts->dev);

		writel(WAIT4INT(0), ts_base+S3C_ADCTSC);
	}
}

static struct timer_list touch_timer =
		TIMER_INITIALIZER(touch_timer_fire, 0, 0);

static irqreturn_t stylus_updown(int irqno, void *param)
{
	unsigned long data0;
	unsigned long data1;
	int updown;

	data0 = readl(ts_base+S3C_ADCDAT0);
	data1 = readl(ts_base+S3C_ADCDAT1);

	updown = (!(data0 & S3C_ADCDAT0_UPDOWN)) && (!(data1 & S3C_ADCDAT1_UPDOWN));

#ifdef CONFIG_TOUCHSCREEN_S3C_DEBUG
       printk(KERN_INFO "   %c\n",	updown ? 'D' : 'U');
#endif

	/* TODO we should never get an interrupt with updown set while
	 * the timer is running, but maybe we ought to verify that the
	 * timer isn't running anyways. */

	if (updown)
	{
		downflag=1;		
		//printk("touch_timer_fire(0)\n");
		touch_timer_fire(0);
	}

	if(ts->s3c_adc_con==ADC_TYPE_2) {
       		__raw_writel(0x0, ts_base+S3C_ADCCLRWK);
        	__raw_writel(0x0, ts_base+S3C_ADCCLRINT);
	}
        
	return IRQ_HANDLED;
}

static irqreturn_t stylus_action(int irqno, void *param)
{
	unsigned long data0;
	unsigned long data1;

	//printk("stylus_action.\n");

	data0 = readl(ts_base+S3C_ADCDAT0);
	data1 = readl(ts_base+S3C_ADCDAT1);

	if(ts->resol_bit==12) {
#if defined(CONFIG_TOUCHSCREEN_NEW)
		ts->yp += S3C_ADCDAT0_XPDATA_MASK_12BIT - (data0 & S3C_ADCDAT0_XPDATA_MASK_12BIT);
		ts->xp += S3C_ADCDAT1_YPDATA_MASK_12BIT - (data1 & S3C_ADCDAT1_YPDATA_MASK_12BIT);
#else 
		ts->xp += data0 & S3C_ADCDAT0_XPDATA_MASK_12BIT;
		ts->yp += data1 & S3C_ADCDAT1_YPDATA_MASK_12BIT;
#endif
	}
	else {
#if defined(CONFIG_TOUCHSCREEN_NEW)
		ts->yp += S3C_ADCDAT0_XPDATA_MASK - (data0 & S3C_ADCDAT0_XPDATA_MASK);
		ts->xp += S3C_ADCDAT1_YPDATA_MASK - (data1 & S3C_ADCDAT1_YPDATA_MASK);
#else
		ts->xp += data0 & S3C_ADCDAT0_XPDATA_MASK;
		ts->yp += data1 & S3C_ADCDAT1_YPDATA_MASK;
#endif	
	}

	ts->count++;

	if (ts->count < (1<<ts->shift)) {
		writel(S3C_ADCTSC_PULL_UP_DISABLE | AUTOPST, ts_base+S3C_ADCTSC);
		writel(readl(ts_base+S3C_ADCCON) | S3C_ADCCON_ENABLE_START, ts_base+S3C_ADCCON);
	} else {
		mod_timer(&touch_timer, jiffies+1);
		writel(WAIT4INT(1), ts_base+S3C_ADCTSC);
	}

	if(ts->s3c_adc_con==ADC_TYPE_2) {
       		__raw_writel(0x0, ts_base+S3C_ADCCLRWK);
        	__raw_writel(0x0, ts_base+S3C_ADCCLRINT);
	}
	
	return IRQ_HANDLED;
}


static struct s3c_ts_mach_info *s3c_ts_get_platdata (struct device *dev)
{
	if (dev->platform_data != NULL)
		return (struct s3c_ts_mach_info *)dev->platform_data;

	return &s3c_ts_default_cfg;
}

/*
 * The functions for inserting/removing us as a module.
 */
static int __init s3c_ts_probe(struct platform_device *pdev)
{
	struct resource *res;
	struct device *dev;
	struct input_dev *input_dev;
	struct s3c_ts_mach_info * s3c_ts_cfg;
	int ret, size;

	dev = &pdev->dev;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (res == NULL) {
		dev_err(dev,"no memory resource specified\n");
		return -ENOENT;
	}

	size = (res->end - res->start) + 1;
	ts_mem = request_mem_region(res->start, size, pdev->name);
	if (ts_mem == NULL) {
		dev_err(dev, "failed to get memory region\n");
		ret = -ENOENT;
		goto err_req;
	}

	ts_base = ioremap(res->start, size);
	if (ts_base == NULL) {
		dev_err(dev, "failed to ioremap() region\n");
		ret = -EINVAL;
		goto err_map;
	}
	
	ts_clock = clk_get(&pdev->dev, "adc");
	if (IS_ERR(ts_clock)) {
		dev_err(dev, "failed to find watchdog clock source\n");
		ret = PTR_ERR(ts_clock);
		goto err_clk;
	}

	clk_enable(ts_clock);

	s3c_ts_cfg = s3c_ts_get_platdata(&pdev->dev);
		
	if ((s3c_ts_cfg->presc&0xff) > 0)
		writel(S3C_ADCCON_PRSCEN | S3C_ADCCON_PRSCVL(s3c_ts_cfg->presc&0xFF),\
				ts_base+S3C_ADCCON);
	else
		writel(0, ts_base+S3C_ADCCON);


	/* Initialise registers */
	if ((s3c_ts_cfg->delay&0xffff) > 0)
		writel(s3c_ts_cfg->delay & 0xffff, ts_base+S3C_ADCDLY);

	if (s3c_ts_cfg->resol_bit==12) {
		switch(s3c_ts_cfg->s3c_adc_con) {
		case ADC_TYPE_2:
			writel(readl(ts_base+S3C_ADCCON)|S3C_ADCCON_RESSEL_12BIT, ts_base+S3C_ADCCON);
			break;

		case ADC_TYPE_1:
			writel(readl(ts_base+S3C_ADCCON)|S3C_ADCCON_RESSEL_12BIT_1, ts_base+S3C_ADCCON);
			break;
			
		default:
			dev_err(dev, "Touchscreen over this type of AP isn't supported !\n");
			break;
		}
	}
	
	writel(WAIT4INT(0), ts_base+S3C_ADCTSC);

	ts = kzalloc(sizeof(struct s3c_ts_info), GFP_KERNEL);
	
	input_dev = input_allocate_device();

	if (!input_dev) {
		ret = -ENOMEM;
		goto err_alloc;
	}
	
	ts->dev = input_dev;

	ts->dev->evbit[0] = ts->dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
	ts->dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);

	if (s3c_ts_cfg->resol_bit==12) {
		input_set_abs_params(ts->dev, ABS_X, 0, 0xFFF, 0, 0);
		input_set_abs_params(ts->dev, ABS_Y, 0, 0xFFF, 0, 0);
	}
	else {
		input_set_abs_params(ts->dev, ABS_X, 0, 0x3FF, 0, 0);
		input_set_abs_params(ts->dev, ABS_Y, 0, 0x3FF, 0, 0);
	}

	input_set_abs_params(ts->dev, ABS_PRESSURE, 0, 1, 0, 0);

	sprintf(ts->phys, "input(ts)");

	ts->dev->name = s3c_ts_name;
	ts->dev->phys = ts->phys;
	ts->dev->id.bustype = BUS_RS232;
	ts->dev->id.vendor = 0xDEAD;
	ts->dev->id.product = 0xBEEF;
	ts->dev->id.version = S3C_TSVERSION;

	ts->shift = s3c_ts_cfg->oversampling_shift;
	ts->resol_bit = s3c_ts_cfg->resol_bit;
	ts->s3c_adc_con = s3c_ts_cfg->s3c_adc_con;
	
	/* For IRQ_PENDUP */
	ts_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	if (ts_irq == NULL) {
		dev_err(dev, "no irq resource specified\n");
		ret = -ENOENT;
		goto err_irq;
	}

	ret = request_irq(ts_irq->start, stylus_updown, IRQF_SAMPLE_RANDOM, "s3c_updown", ts);
	if (ret != 0) {
		dev_err(dev,"s3c_ts.c: Could not allocate ts IRQ_PENDN !\n");
		ret = -EIO;
		goto err_irq;
	}

	/* For IRQ_ADC */
	ts_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
	if (ts_irq == NULL) {
		dev_err(dev, "no irq resource specified\n");
		ret = -ENOENT;
		goto err_irq;
	}

	ret = request_irq(ts_irq->start, stylus_action, IRQF_SAMPLE_RANDOM, "s3c_action", ts);
	if (ret != 0) {
		dev_err(dev, "s3c_ts.c: Could not allocate ts IRQ_ADC !\n");
		ret =  -EIO;
		goto err_irq;
	}

	printk(KERN_INFO "%s got loaded successfully : %d bits\n", s3c_ts_name, s3c_ts_cfg->resol_bit);

	/* All went ok, so register to the input system */
	ret = input_register_device(ts->dev);
	
	if(ret) {
		dev_err(dev, "s3c_ts.c: Could not register input device(touchscreen)!\n");
		ret = -EIO;
		goto fail;
	}

	return 0;

fail:
	free_irq(ts_irq->start, ts->dev);
	free_irq(ts_irq->end, ts->dev);
	
err_irq:
	input_free_device(input_dev);
	kfree(ts);

err_alloc:
	clk_disable(ts_clock);
	clk_put(ts_clock);
	
err_clk:
	iounmap(ts_base);

err_map:
	release_resource(ts_mem);
	kfree(ts_mem);

err_req:
	return ret;
}

static int s3c_ts_remove(struct platform_device *dev)
{
	printk(KERN_INFO "s3c_ts_remove() of TS called !\n");

	disable_irq(IRQ_ADC);
	disable_irq(IRQ_PENDN);
	
	free_irq(IRQ_PENDN, ts->dev);
	free_irq(IRQ_ADC, ts->dev);

	if (ts_clock) {
		clk_disable(ts_clock);
		clk_put(ts_clock);
		ts_clock = NULL;
	}

	input_unregister_device(ts->dev);
	iounmap(ts_base);

	return 0;
}

#ifdef CONFIG_PM
static unsigned int adccon, adctsc, adcdly;

static int s3c_ts_suspend(struct platform_device *dev, pm_message_t state)
{
	adccon = readl(ts_base+S3C_ADCCON);
	adctsc = readl(ts_base+S3C_ADCTSC);
	adcdly = readl(ts_base+S3C_ADCDLY);

	disable_irq(IRQ_ADC);
	disable_irq(IRQ_PENDN);
	
	clk_disable(ts_clock);

	return 0;
}

static int s3c_ts_resume(struct platform_device *pdev)
{
	clk_enable(ts_clock);

	writel(adccon, ts_base+S3C_ADCCON);
	writel(adctsc, ts_base+S3C_ADCTSC);
	writel(adcdly, ts_base+S3C_ADCDLY);
	writel(WAIT4INT(0), ts_base+S3C_ADCTSC);

	enable_irq(IRQ_ADC);
	enable_irq(IRQ_PENDN);
	return 0;
}
#else
#define s3c_ts_suspend NULL
#define s3c_ts_resume  NULL
#endif

static struct platform_driver s3c_ts_driver = {
       .probe          = s3c_ts_probe,
       .remove         = s3c_ts_remove,
       .suspend        = s3c_ts_suspend,
       .resume         = s3c_ts_resume,
       .driver		= {
		.owner	= THIS_MODULE,
		.name	= "s3c-ts",
	},
};

static char banner[] __initdata = KERN_INFO "S3C Touchscreen driver, (c) 2008 Samsung Electronics\n";

static int __init s3c_ts_init(void)
{
	printk(banner);
	return platform_driver_register(&s3c_ts_driver);
}

static void __exit s3c_ts_exit(void)
{
	platform_driver_unregister(&s3c_ts_driver);
}

module_init(s3c_ts_init);
module_exit(s3c_ts_exit);

MODULE_AUTHOR("Samsung AP");
MODULE_DESCRIPTION("S3C touchscreen driver");
MODULE_LICENSE("GPL");

增加互斥量源码
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/init.h>
#include <linux/serio.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/clk.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <mach/hardware.h>
#include <plat/regs-adc.h>
#include <mach/ts.h>
#include <mach/irqs.h>
#define CONFIG_TOUCHSCREEN_S3C_DEBUG
#undef CONFIG_TOUCHSCREEN_S3C_DEBUG
/* For ts->dev.id.version */
#define S3C_TSVERSION 0x0101
#define WAIT4INT(x)  (((x)<<8) | \
       S3C_ADCTSC_YM_SEN | S3C_ADCTSC_YP_SEN | S3C_ADCTSC_XP_SEN | \
       S3C_ADCTSC_XY_PST(3))
#define AUTOPST      (S3C_ADCTSC_YM_SEN | S3C_ADCTSC_YP_SEN | S3C_ADCTSC_XP_SEN | \
       S3C_ADCTSC_AUTO_PST | S3C_ADCTSC_XY_PST(0))

#define DEBUG_LVL    KERN_DEBUG

/* Touchscreen default configuration */
struct s3c_ts_mach_info s3c_ts_default_cfg __initdata = {
                .delay =   5000,//10000,
                .presc =   49,
                .oversampling_shift =  4,//2,
  .resol_bit =   10
};
/*
 * Definitions & global arrays.
 */
static char *s3c_ts_name = "S3C TouchScreen";
static void __iomem   *ts_base;
static struct resource  *ts_mem;
static struct resource  *ts_irq;
static struct clk  *ts_clock;
static struct s3c_ts_info  *ts;
static int downflag=0;

#ifdef  CONFIG_FORLINX6410_ADC
DEFINE_SEMAPHORE(ADC_LOCK);
/* Indicate who is using the ADC controller */
#define LOCK_FREE  0
#define LOCK_TS   1
#define LOCK_ADC  2
static int adc_lock_id = LOCK_FREE;
#define ADC_free()  (adc_lock_id == LOCK_FREE)
#define ADC_locked4TS() (adc_lock_id == LOCK_TS)
static inline int s3c_ts_adc_lock(int id) {
        int ret;
        ret = down_trylock(&ADC_LOCK);
        if (!ret) {
                adc_lock_id = id;
        }
        return ret;
}
static inline void s3c_ts_adc_unlock(void) {
        adc_lock_id = 0;
        up(&ADC_LOCK);
}
static unsigned int _adccon, _adctsc, _adcdly;
int X6410_adc_acquire_io(void) {
        int ret;
        ret = s3c_ts_adc_lock(LOCK_ADC);
        if (!ret) {
                _adccon = readl(ts_base + S3C_ADCCON);
                _adctsc = readl(ts_base + S3C_ADCTSC);
                _adcdly = readl(ts_base + S3C_ADCDLY);
                printk("forlinx debug****X6410_adc_acquire_io();.\n");

        }
 
        return ret;
}
EXPORT_SYMBOL(X6410_adc_acquire_io);
void X6410_adc_release_io(void) {
        writel(_adccon, ts_base + S3C_ADCCON);
        writel(_adctsc, ts_base + S3C_ADCTSC);
        writel(_adcdly, ts_base + S3C_ADCDLY);
        writel(WAIT4INT(0), ts_base + S3C_ADCTSC);
        s3c_ts_adc_unlock();
        printk("forlinx debug*****X6410_adc_release_io();.\n");

}
EXPORT_SYMBOL(X6410_adc_release_io);
#endif
static void touch_timer_fire(unsigned long data)
{
 unsigned long data0;
 unsigned long data1;
        int pendown;
#ifdef CONFIG_FORLINX6410_ADC
        if (!ADC_locked4TS()) {
                /* Note: pen UP interrupt detected and handled, the lock is released,
                 * so do nothing in the timer which started by ADC ISR. */
                return;
        }
#endif
 data0 = readl(ts_base+S3C_ADCDAT0);
 data1 = readl(ts_base+S3C_ADCDAT1);
        pendown = (!(data0 & S3C_ADCDAT0_UPDOWN)) && (!(data1 & S3C_ADCDAT1_UPDOWN));
        if (pendown) {
                //down
                //printk("pendown=1.\n");
  if (ts->count) {
#ifdef CONFIG_TOUCHSCREEN_S3C_DEBUG
   {
    struct timeval tv;
    do_gettimeofday(&tv);
    printk(KERN_INFO "T: %06d, X: %03ld, Y: %03ld\n", (int)tv.tv_usec, ts->xp, ts->yp);
   }
#endif
      if(downflag==0)
                     {
   input_report_abs(ts->dev, ABS_X, ts->xp);
   input_report_abs(ts->dev, ABS_Y, ts->yp);
   input_report_key(ts->dev, BTN_TOUCH, 1);
   input_report_abs(ts->dev, ABS_PRESSURE, 1);
   input_sync(ts->dev);
                     }
                    else
                    {
                       // printk("downflag=1.ignore this data.\n");
                        downflag=0;
                    }
                }
                ts->xp = 0;
                ts->yp = 0;
                ts->count = 0;
                writel(S3C_ADCTSC_PULL_UP_DISABLE | AUTOPST, ts_base+S3C_ADCTSC);
                writel(readl(ts_base+S3C_ADCCON) | S3C_ADCCON_ENABLE_START, ts_base+S3C_ADCCON);
        }
        else {
                //up
                ts->count = 0;
                input_report_key(ts->dev, BTN_TOUCH, 0);
                input_report_abs(ts->dev, ABS_PRESSURE, 0);
                input_sync(ts->dev);
  writel(WAIT4INT(0), ts_base+S3C_ADCTSC);

#ifdef CONFIG_FORLINX6410_ADC
                if (ADC_locked4TS()) {
                        s3c_ts_adc_unlock();
                        printk("forlinx debug*****s3c_ts_adc_unlock();.\n");
                }
#endif
 }
 

}
static struct timer_list touch_timer =
  TIMER_INITIALIZER(touch_timer_fire, 0, 0);
static irqreturn_t stylus_updown(int irqno, void *param)
{
 unsigned long data0;
 unsigned long data1;
#ifdef CONFIG_FORLINX6410_ADC
        if (!ADC_locked4TS()) {
                if (s3c_ts_adc_lock(LOCK_TS)) {
                        /* Locking ADC controller failed */
                        printk("Lock ADC failed, %d\n", adc_lock_id);
                        return IRQ_HANDLED;
                }
                printk("forlinx debug***** s3c_ts_adc_lock(LOCK_TS);.\n");
        }
#endif
 data0 = readl(ts_base+S3C_ADCDAT0);
 data1 = readl(ts_base+S3C_ADCDAT1);
 /* TODO we should never get an interrupt with updown set while
  * the timer is running, but maybe we ought to verify that the
  * timer isn't running anyways. */

        touch_timer_fire(0);

 if(ts->s3c_adc_con==ADC_TYPE_2) {
         __raw_writel(0x0, ts_base+S3C_ADCCLRWK);
         __raw_writel(0x0, ts_base+S3C_ADCCLRINT);
 }
        
 return IRQ_HANDLED;
}
static irqreturn_t stylus_action(int irqno, void *param)
{
 unsigned long data0;
 unsigned long data1;

#ifdef CONFIG_FORLINX6410_ADC
        if (!ADC_locked4TS()) {
                if (ADC_free()) {
                        printk("Unexpected\n");
                        /* Clear ADC interrupt */
                        __raw_writel(0x0, ts_base + S3C_ADCCLRINT);
                }
                return IRQ_HANDLED;
        }
#endif
 //printk("stylus_action.\n");
 data0 = readl(ts_base+S3C_ADCDAT0);
 data1 = readl(ts_base+S3C_ADCDAT1);
 if(ts->resol_bit==12) {
#if defined(CONFIG_TOUCHSCREEN_NEW)
  ts->yp += S3C_ADCDAT0_XPDATA_MASK_12BIT - (data0 & S3C_ADCDAT0_XPDATA_MASK_12BIT);
  ts->xp += S3C_ADCDAT1_YPDATA_MASK_12BIT - (data1 & S3C_ADCDAT1_YPDATA_MASK_12BIT);
#else 
  ts->xp += data0 & S3C_ADCDAT0_XPDATA_MASK_12BIT;
  ts->yp += data1 & S3C_ADCDAT1_YPDATA_MASK_12BIT;
#endif
 }
 else {
#if defined(CONFIG_TOUCHSCREEN_NEW)
  ts->yp += S3C_ADCDAT0_XPDATA_MASK - (data0 & S3C_ADCDAT0_XPDATA_MASK);
  ts->xp += S3C_ADCDAT1_YPDATA_MASK - (data1 & S3C_ADCDAT1_YPDATA_MASK);
#else
  ts->xp += data0 & S3C_ADCDAT0_XPDATA_MASK;
  ts->yp += data1 & S3C_ADCDAT1_YPDATA_MASK;
#endif 
 }
 ts->count++;
 if (ts->count < (1<<ts->shift)) {
  writel(S3C_ADCTSC_PULL_UP_DISABLE | AUTOPST, ts_base+S3C_ADCTSC);
  writel(readl(ts_base+S3C_ADCCON) | S3C_ADCCON_ENABLE_START, ts_base+S3C_ADCCON);
 } else {
  mod_timer(&touch_timer, jiffies+1);
  writel(WAIT4INT(1), ts_base+S3C_ADCTSC);
 }
 if(ts->s3c_adc_con==ADC_TYPE_2) {
         __raw_writel(0x0, ts_base+S3C_ADCCLRWK);
         __raw_writel(0x0, ts_base+S3C_ADCCLRINT);
 }
 
 return IRQ_HANDLED;
}

static struct s3c_ts_mach_info *s3c_ts_get_platdata (struct device *dev)
{
 if (dev->platform_data != NULL)
  return (struct s3c_ts_mach_info *)dev->platform_data;
 return &s3c_ts_default_cfg;
}
/*
 * The functions for inserting/removing us as a module.
 */
static int __init s3c_ts_probe(struct platform_device *pdev)
{
 struct resource *res;
 struct device *dev;
 struct input_dev *input_dev;
 struct s3c_ts_mach_info * s3c_ts_cfg;
 int ret, size;
 dev = &pdev->dev;
 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 if (res == NULL) {
  dev_err(dev,"no memory resource specified\n");
  return -ENOENT;
 }
 size = (res->end - res->start) + 1;
 ts_mem = request_mem_region(res->start, size, pdev->name);
 if (ts_mem == NULL) {
  dev_err(dev, "failed to get memory region\n");
  ret = -ENOENT;
  goto err_req;
 }
 ts_base = ioremap(res->start, size);
 if (ts_base == NULL) {
  dev_err(dev, "failed to ioremap() region\n");
  ret = -EINVAL;
  goto err_map;
 }
 
 ts_clock = clk_get(&pdev->dev, "adc");
 if (IS_ERR(ts_clock)) {
  dev_err(dev, "failed to find watchdog clock source\n");
  ret = PTR_ERR(ts_clock);
  goto err_clk;
 }
 clk_enable(ts_clock);
 s3c_ts_cfg = s3c_ts_get_platdata(&pdev->dev);
  
 if ((s3c_ts_cfg->presc&0xff) > 0)
  writel(S3C_ADCCON_PRSCEN | S3C_ADCCON_PRSCVL(s3c_ts_cfg->presc&0xff),
    ts_base+S3C_ADCCON);
 else
  writel(0, ts_base+S3C_ADCCON);

 /* Initialise registers */
 if ((s3c_ts_cfg->delay&0xffff) > 0)
  writel(s3c_ts_cfg->delay & 0xffff, ts_base+S3C_ADCDLY);
 if (s3c_ts_cfg->resol_bit==12) {
  switch(s3c_ts_cfg->s3c_adc_con) {
  case ADC_TYPE_2:
   writel(readl(ts_base+S3C_ADCCON)|S3C_ADCCON_RESSEL_12BIT, 
   ts_base+S3C_ADCCON);
   break;
  case ADC_TYPE_1:
   writel(readl(ts_base+S3C_ADCCON)|S3C_ADCCON_RESSEL_12BIT_1, 
   ts_base+S3C_ADCCON);
   break;
   
  default:
   dev_err(dev, "Touchscreen over this type of AP isn't supported !\n");
   break;
  }
 }
 
 writel(WAIT4INT(0), ts_base+S3C_ADCTSC);
 ts = kzalloc(sizeof(struct s3c_ts_info), GFP_KERNEL);
 
 input_dev = input_allocate_device();
 if (!input_dev) {
  ret = -ENOMEM;
  goto err_alloc;
 }
 
 ts->dev = input_dev;
 ts->dev->evbit[0] = ts->dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 ts->dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
 if (s3c_ts_cfg->resol_bit==12) {
  input_set_abs_params(ts->dev, ABS_X, 0, 0xFFF, 0, 0);
  input_set_abs_params(ts->dev, ABS_Y, 0, 0xFFF, 0, 0);
 }
 else {
  input_set_abs_params(ts->dev, ABS_X, 0, 0x3FF, 0, 0);
  input_set_abs_params(ts->dev, ABS_Y, 0, 0x3FF, 0, 0);
 }
 input_set_abs_params(ts->dev, ABS_PRESSURE, 0, 1, 0, 0);
 sprintf(ts->phys, "input(ts)");
 ts->dev->name = s3c_ts_name;
 ts->dev->phys = ts->phys;
 ts->dev->id.bustype = BUS_RS232;
 ts->dev->id.vendor = 0xDEAD;
 ts->dev->id.product = 0xBEEF;
 ts->dev->id.version = S3C_TSVERSION;
 ts->shift = s3c_ts_cfg->oversampling_shift;
 ts->resol_bit = s3c_ts_cfg->resol_bit;
 ts->s3c_adc_con = s3c_ts_cfg->s3c_adc_con;
 
 /* For IRQ_PENDUP */
 ts_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 if (ts_irq == NULL) {
  dev_err(dev, "no irq resource specified\n");
  ret = -ENOENT;
  goto err_irq;
 }
 ret = request_irq(ts_irq->start, stylus_updown, IRQF_SAMPLE_RANDOM, "s3c_updown", ts);
 if (ret != 0) {
  dev_err(dev,"s3c_ts.c: Could not allocate ts IRQ_PENDN !\n");
  ret = -EIO;
  goto err_irq;
 }
 /* For IRQ_ADC */
 ts_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
 if (ts_irq == NULL) {
  dev_err(dev, "no irq resource specified\n");
  ret = -ENOENT;
  goto err_irq;
 }
        ret = request_irq(ts_irq->start, stylus_action, IRQF_SAMPLE_RANDOM | IRQF_SHARED,
   "s3c_action", ts);
 if (ret != 0) {
  dev_err(dev, "s3c_ts.c: Could not allocate ts IRQ_ADC !\n");
  ret =  -EIO;
  goto err_irq;
 }
 printk(KERN_INFO "%s got loaded successfully : %d bits\n", s3c_ts_name, s3c_ts_cfg->resol_bit);
 /* All went ok, so register to the input system */
 ret = input_register_device(ts->dev);
 
 if(ret) {
  dev_err(dev, "s3c_ts.c: Could not register input device(touchscreen)!\n");
  ret = -EIO;
  goto fail;
 }
 return 0;
fail:
 free_irq(ts_irq->start, ts->dev);
 free_irq(ts_irq->end, ts->dev);
 
err_irq:
 input_free_device(input_dev);
 kfree(ts);
err_alloc:
 clk_disable(ts_clock);
 clk_put(ts_clock);
 
err_clk:
 iounmap(ts_base);
err_map:
 release_resource(ts_mem);
 kfree(ts_mem);
err_req:
 return ret;
}
static int s3c_ts_remove(struct platform_device *dev)
{
 printk(KERN_INFO "s3c_ts_remove() of TS called !\n");
 disable_irq(IRQ_ADC);
 disable_irq(IRQ_PENDN);
 
 free_irq(IRQ_PENDN, ts->dev);
 free_irq(IRQ_ADC, ts->dev);
 if (ts_clock) {
  clk_disable(ts_clock);
  clk_put(ts_clock);
  ts_clock = NULL;
 }
 input_unregister_device(ts->dev);
 iounmap(ts_base);
 return 0;
}
#ifdef CONFIG_PM
static unsigned int adccon, adctsc, adcdly;
static int s3c_ts_suspend(struct platform_device *dev, pm_message_t state)
{
 adccon = readl(ts_base+S3C_ADCCON);
 adctsc = readl(ts_base+S3C_ADCTSC);
 adcdly = readl(ts_base+S3C_ADCDLY);
 disable_irq(IRQ_ADC);
 disable_irq(IRQ_PENDN);
 
 clk_disable(ts_clock);
 return 0;
}
static int s3c_ts_resume(struct platform_device *pdev)
{
 clk_enable(ts_clock);
 writel(adccon, ts_base+S3C_ADCCON);
 writel(adctsc, ts_base+S3C_ADCTSC);
 writel(adcdly, ts_base+S3C_ADCDLY);
 writel(WAIT4INT(0), ts_base+S3C_ADCTSC);
 enable_irq(IRQ_ADC);
 enable_irq(IRQ_PENDN);
 return 0;
}
#else
#define s3c_ts_suspend NULL
#define s3c_ts_resume  NULL
#endif
static struct platform_driver s3c_ts_driver = {
       .probe          = s3c_ts_probe,
       .remove         = s3c_ts_remove,
       .suspend        = s3c_ts_suspend,
       .resume         = s3c_ts_resume,
       .driver  = {
  .owner = THIS_MODULE,
  .name = "s3c-ts",
 },
};
static char banner[] __initdata = KERN_INFO "S3C Touchscreen driver, (c) 2008 Samsung Electronics\n";
static int __init s3c_ts_init(void)
{
 printk(banner);
 return platform_driver_register(&s3c_ts_driver);
}
static void __exit s3c_ts_exit(void)
{
 platform_driver_unregister(&s3c_ts_driver);
}
module_init(s3c_ts_init);
module_exit(s3c_ts_exit);
MODULE_AUTHOR("Samsung AP");
MODULE_DESCRIPTION("S3C touchscreen driver");
MODULE_LICENSE("GPL");


 

彬ye
关注
专栏目录
ADC 驱动移植
一个人的力量很渺小，一群人的力量很可怕......
04-10 775
（1）Linux-2.6.32.2 内核并没有提供支持S3C2440 的ADC 驱动程序，所以需要在drivers/char 目录下，创建一个驱动程序的文件名为： mini2440_adc.c（囯嵌提供） 在 S3C2440 芯片中，AD 输入和触摸屏接口使用共同的A/D 转换器 ADC 驱动和触摸屏驱动若想共存，就必须解决共享“A/D 转换器”资源这个问 题，因此在ADC 驱动程序中声明
6410之AD驱动与触摸屏共存（上）
yuzeze的专栏
04-15 333
AD驱动源码#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #i
linux-2.6.32在mini2440开发板上移植（8）之添加ADC驱动程序
weixianya的专栏
03-31 683
添加ADC驱动程序 编者：由于内核没有支持S3C2440的ADC驱动，在这里增加ADC驱动。友善的手册对这个介绍的还算相当详细，所以直接按照手册进行。里面的代码也有详细的注释。ADC驱动属于字符型设备，在这里以杂项设备也有的翻译为混杂设备，进行实现。   1 、关于S3C2440 的ADC 和触摸屏接口 Linux-2.6.32.2 内核并没有提供支持S3C2440 的ADC
Linux设备驱动开发基础---字符设备驱动程序开发之mini2440_ADC驱动
DreamCatcher100的专栏
07-23 1125
一、硬件原理分析 S3C2440内部ADC结构图 我们从上面的结构图和数据手册可以知道，该ADC模块总共有8个通道可以进行模拟信号的输入，分别是AIN0、AIN1、AIN2、AIN3、 YM、YP、XM、XP。那么ADC是怎么实现模拟信号到数字信号的转换呢？首先模拟信号从任一通道输入，然后设定寄存器中预分频器的值来确定AD转换器频率，最后ADC将模拟信号转换为数字信号保存到ADC数据寄
linux-2.6.32在mini2440开发板上移植 --添加ADC驱动程序
viewsky11的专栏
09-20 1209
添加ADC驱动程序 编者：由于内核没有支持S3C2440的ADC驱动，在这里增加ADC驱动。友善的手册对这个介绍的还算相当详细，所以直接按照手册进行。里面的代码也有详细的注释。ADC驱动属于字符型设备，在这里以杂项设备也有的翻译为混杂设备，进行实现。   1 、关于S3C2440 的ADC 和触摸屏接口 Linux-2.6.32.2 内核并没有提供支持S3C2440 的ADC
linux2.6.32.2 mini2440平台移植-- ADC 驱动移植
shawn
03-19 1091
1.2.1  关于 S3C2440 的 ADC 和触摸屏接口   Linux-2.6.32.2 内核并没有提供支持 S3C2440 的 ADC 驱动程序，因此我们自行设计了一个，这个驱动比较简单，属于字符设备，。在 S3C2440 芯片中，AD 输入和触摸屏接口使用共同的 A/D  转换器，见S3C2440芯片手册第 16 章节，如图。 1.2.2  在内核中添加 AD
【开发板资讯】友善推出mini6410 之后不久再推出tiny6410（mini6410和tiny6410有何不同？市场定位如何？）...
weixin_34332905的博客
02-16 536
套餐简介 6410开发板面世已经2年多，但价格相比2440，一直高不可攀，最主要的原因之一就是软件极其不完善，学习资源缺乏，导致不良率高，用户使用困难。但是，经过半年来的努力，友善之臂已经大大完善了6410开发平台...
linux-2.6.32在mini2440开发板上移植 添加ADC驱动程序
09-26 140
添加ADC驱动程序 编者：由于内核没有支持S3C2440的ADC驱动，在这里增加ADC驱动。友善的手册对这个介绍的还算相当详细，所以直接按照手册进行。里面的代码也有详细的注释。ADC驱动属于字符型设备，在这里以杂项设备也有的翻译为混杂设备，进行实现。   1 、关于S3C2440 的ADC 和触摸屏接口 Linux-2.6.32.2 内核并没有提供支持S3C2440 的ADC
独创简单易用的Qtopia-2.2.0 + QtE-4.6.3双图形系统系统共存，无缝切换
默默的努力
05-08 2235
我们的服务理念：产品本身就是服务的一种体现，只有做到好用，易用和易得，才能为客户节省时间，提高效率和带来真正的价值；我们的设计理念也正是基于此宗旨，这是你看到我们的产品由表及理如此爽心悦目的主要原因，它无处不体现了设计人员的良苦用心。   经典实用的Qtopia-2.2.0   最新的QtE-4.6.3
Android 面试真题收录~
1
04-08 1759
Android是一种基于Linux的自由及开放源代码的操作系统，主要使用于移动设备，如智能手机和平板电脑，由Google公司和开放手机联盟领导及开发。这里会不断收集和更新Android基础相关的面试题，目前已收集100题。 1.Android系统的架构 应用程序 Android会同一系列核心应用程序包一起发布，该应用程序包包括Email客户端，SMS短消息程序，日历，地图，浏览器，联系人管理程序等。所有的应用程序都是使用JAVA语言编写的。 应用程序框架 开发人员可以完全访问核心应用程序所使用的API框架（
华为云计算HCIE学习笔记-FusionAccess
热门推荐
魔仙堡的仙女的博客
12-22 1万+
华为FusionAccess桌面云解决方案是基于华为云平台的一种虚拟桌面应用，通过在云平台上部署华为桌面云软件，使终端用户通过瘦客户端或者其他设备来访问跨平台的整个客户桌面和应用。 桌面云就是一个桌面池，这个池子中每一个桌面都有一个User来关联，信息靠HDC维护，写在DB中。 FusionAccess就是VDI（虚拟桌面基础设施）Virtual Desktop Infrastructure。FA是实现方式，VDI是一套解决方案。用虚拟桌面来替代物理PC。 物理PC：本地计算/处理，数据local
基于51单片机的智能晾衣架（课设）
最新发布
LuChenYa_的博客
01-04 1228
大二课设，51单片机，智能晾衣架
计算机算法常用术语中英对照（分为两部分 其中一部分表格形式 ）
weixin_30488085的博客
06-25 4986
第一部分 Data Structures 基本数据结构 Dictionaries 字典 Priority Queues 堆 Graph Data Structures 图 Set Data Structures 集合 Kd-Trees 线段树 Numerical Problems 数值问题 Solving Linear Equations 线性方程组 B...
OK6410.logo显示.16BPP
06-18 1716
uboot下有现成的LCD驱动模板，原来是用于MPC823和PXA250的，我们需要在s3c6410这个ARM11的uboot中增加LCD的驱动，可以在这个基础上修改。具体分以下几步：         1.  修改配置头文件，是整个工程支持LCD。          在修改include/configs/smdk6410.h 增加一行         #define CONFIG
ok6410 2g NandFalsh 256ram tftp挂载zImage
10-03 714
1.Ubuntu  开启tftp TFTP 环境搭建： (1) Setup tftp server files （下载并安装 tftp） $ sudo apt-get install tftpd tftp openbsd-inetd (2) make a tftp directory (新建tftp目录和改变其属性) Here we make /home/myzr/tftpt b
K8s 很难么？带你从头到尾捋一遍，不信你学不会
民工哥的博客
02-23 9166
点击关注公众号，回复“1024”获取2TB学习资源！为什么要学习 Kubernetes?虽然 Docker 已经很强大了，但是在实际使用上还是有诸多不便，比如集群管理、资源调度、文件管理等...
嵌入式Linux下AD7873触摸屏驱动设计与实现
"基于嵌入式Linux系统下的AD7873触摸屏驱动系统设计" 本文主要探讨了在嵌入式Linux环境下，如何设计并实现基于AD7873触摸屏芯片的驱动系统，特别是在飞思卡尔i.MX27处理器平台上的应用。AD7873是一款12位分辨率的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值