6410之AD驱动与触摸屏共存(下)

触摸屏驱动源码
#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");


 

你可能感兴趣的:(c,timer,struct,report,Module,input)