tsc2007.c

详细介绍了德州仪器触摸屏tsc2007在linux下驱动的编写

#include "tsc2007.h"
#include "tsc2007_S5.h"


#include <linux/module.h>
#include <linux/hrtimer.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/i2c.h>
#include <linux/type.h>



/*Command Define*/
#define TSC2007_MEASURE_TEMP0           (0x0 << 4)
#define TSC2007_MEASURE_AUX             (0x2 << 4)
#define TSC2007_MEASURE_TEMP1           (0x4 << 4)
#define TSC2007_ACTIVATE_XN             (0x8 << 4)
#define TSC2007_ACTIVATE_YN             (0x9 << 4)
#define TSC2007_ACTIVATE_YP_XN          (0xa << 4)
#define TSC2007_SETUP                   (0xb << 4)
#define TSC2007_MEASURE_X               (0xc << 4)
#define TSC2007_MEASURE_Y               (0xd << 4)
#define TSC2007_MEASURE_Z1              (0xe << 4)
#define TSC2007_MEASURE_Z2              (0xf << 4) 
#define TSC2007_POWER_OFF_IRQ_EN        (0x0 << 2)
#define TSC2007_ADC_ON_IRQ_DIS0         (0x1 << 2)
#define TSC2007_ADC_OFF_IRQ_EN          (0x2 << 2)
#define TSC2007_ADC_ON_IRQ_DIS1         (0x3 << 2)
#define TSC2007_12BIT                   (0x0 << 1)
#define TSC2007_8BIT                    (0x1 << 1)

#define MAX_8BIT                       ((1 << 8) - 1)
#define ADC_ON_8BIT   		 (TSC2007_8BIT | TSC2007_ADC_ON_IRQ_DIS0)
#define READ_Y_8BIT         	 	 (ADC_ON_8BIT | TSC2007_MEASURE_Y)
#define READ_Z1_8BIT        	 (ADC_ON_8BIT | TSC2007_MEASURE_Z1)
#define READ_Z2_8BIT          	(ADC_ON_8BIT | TSC2007_MEASURE_Z2)
#define READ_X_8BIT          	(ADC_ON_8BIT | TSC2007_MEASURE_X)
#define PWRDOWN_8BIT         	 (TSC2007_8BIT | TSC2007_POWER_OFF_IRQ_EN)

#define MAX_12BIT                       ((1 << 12) - 1)
#define ADC_ON_12BIT   		 (TSC2007_12BIT | TSC2007_ADC_ON_IRQ_DIS0)
#define READ_Y_12BIT         	 (ADC_ON_12BIT | TSC2007_MEASURE_Y)
#define READ_Z1_12BIT        	 (ADC_ON_12BIT | TSC2007_MEASURE_Z1)
#define READ_Z2_12BIT          	(ADC_ON_12BIT | TSC2007_MEASURE_Z2)
#define READ_X_12BIT          	(ADC_ON_12BIT | TSC2007_MEASURE_X)
#define PWRDOWN_12BIT          (TSC2007_12BIT | TSC2007_POWER_OFF_IRQ_EN)

/*Structure*/
struct  ts_event {
         u16     x;		/*unsigned 16bit interger*/
         u16     y;
         u16     z1, z2;
 };


struct tsc2007 {
         struct input_dev        *input;
         char                    phys[32];
         struct hrtimer          timer;
         struct ts_event         tc;

         struct i2c_client       *client;
 
         spinlock_t              lock;
 
         u16                     model;
         u16                     x_plate_ohms;
 
         unsigned             pendown;
         int                     	irq;
		 
    	  int 				ts_calibration_success;
		  
         int                      (*get_pendown_state)(void);
         void                    (*clear_penirq)(void);
};

static inline int tsc2007_xfer_12BIT(struct tsc2007 *tsc, u8 cmd)
{
	      s32 data;
	      u16 val;

            data = i2c_smbus_read_word_data(tsc->client, cmd);/*Reference to linux/i2c.h*/
            if (data < 0)
	    {
                 dev_err(&tsc->client->dev, "i2c io error: %d\n", data);
                 return data;
            }
 
        /* The protocol and raw data format from i2c interface:
          * S Addr Wr [A] Comm [A] S Addr Rd [A] [DataLow] A [DataHigh] NA P
          * Where DataLow has [D11-D4], DataHigh has [D3-D0 << 4 | Dummy 4bit].
          */
        val = swab16(data) >> 4;/*Exchange the lower 8 bit data with the higher 8 bit data.Therefore, it's SMALL_ENDIAN format*/
        dev_dbg(&tsc->client->dev, "data: 0x%x, val: 0x%x\n", data, val);/*Output information function.Prototype:#define dev_dbg(dev, format, arg...) */
        return val;	
 }

static void tsc2007_send_event_12BIT(void *tsc)
{
       struct tsc2007  *ts = tsc;
        u32             rt;
        u16             x, y, z1, z2;
 
         x = ts->tc.x;
         y = ts->tc.y;
         z1 = ts->tc.z1;
         z2 = ts->tc.z2;

         /* range filtering */
         if (x == MAX_12BIT)
                 x = 0;

        if (likely(x && z1))			/*It's more likely to run the following code instead of the code after else*/
	{
         /* compute touch pressure resistance using equation #1 */
                 rt = z2;                     /*rt is Rtouch*/
                 rt -= z1;
                 rt *= x;
                 rt *= ts->x_plate_ohms;
                 rt /= z1;
                 rt = (rt + 2047) >> 12;//eric
         } else
                 rt = 0;

        /* Sample found inconsistent by debouncing or pressure is beyond
          * the maximum. Don't report it to user space, repeat at least
          * once more the measurement
          */
        if (rt > MAX_12BIT) {
                dev_dbg(&ts->client->dev, "ignored pressure %d\n", rt);

                hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_PERIOD),HRTIMER_MODE_REL); /*Start timer, the max counter is TS_POLL_PERIOD*/
                return;
        }

        /* NOTE: We can't rely on the pressure to determine the pen down
          * state, even this controller has a pressure sensor.  The pressure
          * value can fluctuate for quite a while after lifting the pen and
          * in some cases may not even settle at the expected value.
         *
          * The only safe way to check for the pen up condition is in the
         * timer by reading the pen signal state (it's a GPIO _and_ IRQ).
         */
         if (rt) {
                struct input_dev *input = ts->input;
 
                 if (!ts->pendown) 
		{
                         dev_dbg(&ts->client->dev, "DOWN\n");
 
                         input_report_key(input, BTN_TOUCH, 1);/*Report to linux that pen down*/
                         ts->pendown = 1;
                }
 
                 input_report_abs(input, ABS_X, x);  	/*Report the abs location function*/
                 input_report_abs(input, ABS_Y, y);
                 input_report_abs(input, ABS_PRESSURE, rt);
 
                 input_sync(input);   	/*Sync the event, tell linux that driver had reported a whole report*/

                 dev_dbg(&ts->client->dev, "point(%4d,%4d), pressure (%4u)\n", x, y, rt);
         }
 
	          hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_PERIOD), HRTIMER_MODE_REL);
 }
 
 static int tsc2007_read_values_12BIT(struct tsc2007 *tsc)
{
         /* y- still on; turn on only y+ (and ADC) */
         tsc->tc.y = tsc2007_xfer_12BIT(tsc, READ_Y_12BIT);
 
         /* turn y- off, x+ on, then leave in lowpower */
         tsc->tc.x = tsc2007_xfer_12BIT(tsc, READ_X_12BIT);
 
        /* turn y+ off, x- on; we'll use formula #1 */
         tsc->tc.z1 = tsc2007_xfer_12BIT(tsc, READ_Z1_12BIT);
         tsc->tc.z2 = tsc2007_xfer_12BIT(tsc, READ_Z2_12BIT);
 
        /* power down */
        tsc2007_xfer_12BIT(tsc, PWRDOWN_12BIT);
 
        return 0;
}


 static enum hrtimer_restart tsc2007_timer(struct hrtimer *handle)
{
        struct tsc2007 *ts = container_of(handle, struct tsc2007, timer);/*Get the address of struct tsc2007 from timer*/

        spin_lock_irq(&ts->lock);	/*Add lock and close interrupt*/
 
        if (unlikely(!ts->get_pendown_state() && ts->pendown)) {
                 struct input_dev *input = ts->input;

                 dev_dbg(&ts->client->dev, "UP\n");

                 input_report_key(input, BTN_TOUCH, 0);
                 input_report_abs(input, ABS_PRESSURE, 0);
                 input_sync(input);
 
                 ts->pendown = 0;
                 enable_irq(ts->irq);
         } else {
                 /* pen is still down, continue with the measurement */
                 dev_dbg(&ts->client->dev, "pen is still down\n");
 
                 tsc2007_read_values_12BIT(ts);
                 tsc2007_send_event_12BIT(ts);
         }
 
	        spin_unlock_irq(&ts->lock);
 
	        return HRTIMER_NORESTART;
}
 

static irqreturn_t tsc2007_irq(int irq, void *handle)
{
	       struct tsc2007 *ts = handle;
	       unsigned long flags;
 
	       spin_lock_irqsave(&ts->lock, flags);/*Save the status of current interrupt and forbidden the native interrupt.Then get the lock*/
 
	       if (likely(ts->get_pendown_state())) 
		{
                 disable_irq(ts->irq);
                 hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_DELAY),HRTIMER_MODE_REL);
         	}
 
         if (ts->clear_penirq)
                 ts->clear_penirq();

         spin_unlock_irqrestore(&ts->lock, flags);/*Unlock the resource, return to the former state*/
 
         return IRQ_HANDLED;
}

// Default calibration parameters
struct PanelDefaults
{
   int x_min, x_max, y_min, y_max;
};

const static struct PanelDefaults Defaults = {
   .x_min = TS_X_MIN,
   .x_max = TS_X_MAX,
   .y_min = TS_Y_MIN,
   .y_max = TS_Y_MAX,
};

static int tsc2007_attach_adapter(struct i2c_adapter *adapter) {

    return i2c_probe(adapter, &addr_data, tsc2007_probe);
}

/*Detect the slave device*/
static int tsc2007_probe(struct i2c_adapter *adapter, const struct i2c_device_id *id)
{
	struct i2c_client *client;
	struct tsc2007 *ts;
       struct tsc2007_platform_data/*just like struct i2c_adapter *adapter*/*pdata = pdata = client->dev.platform_data;
       struct input_dev *input_dev;
 	const struct PanelDefaults *pDefaults = &Defaults;
	int err;
	
       if (!pdata) 
	{	
		dev_err(&client->dev, "platform data is required!\n");
	       return -EINVAL;
	}
	/*To see whether the client support our need*/
       if (!i2c_check_functionality(client->adapter,I2C_FUNC_SMBUS_READ_WORD_DATA))
	   	
              return -EIO;
 	/*We have a vaild client,begin to construct the client*/
       ts = kzalloc(sizeof(struct tsc2007), GFP_KERNEL);
       input_dev = input_allocate_device();
       if (!ts || !input_dev) 
	{
                 err = -ENOMEM;
	          goto err_free_mem;
       }
	   
		
	memset(ts, 0, sizeof(struct tsc2007));
	
	/* fill in the per-client details */
       ts->client = client;
       i2c_set_clientdata(client, ts);/*save the client data */

       ts->input = input_dev;
 
       hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
       ts->timer.function = tsc2007_timer;

       spin_lock_init(&ts->lock);
 
       ts->model             = pdata->model;
       ts->x_plate_ohms      = pdata->x_plate_ohms;
       ts->get_pendown_state = pdata->get_pendown_state;
       ts->clear_penirq      = pdata->clear_penirq;
 
       pdata->init_platform_hw();

       snprintf(ts->phys, sizeof(ts->phys), "%s/input0", client->dev.bus_id);
 
       input_dev->name = "TSC2007 Touchscreen";
       input_dev->phys = ts->phys;
       input_dev->id.bustype = BUS_I2C;
       input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
       input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
 
       input_set_abs_params(input_dev, ABS_X, 0, MAX_12BIT, 0, 0);
       input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, 0, 0);
       input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_12BIT, 0, 0);

       tsc2007_read_values_12BIT(ts);
 
       ts->irq = client->irq;
 
       err = request_irq(ts->irq, tsc2007_irq, 0, client->dev.driver->name, ts);
       if (err < 0)
	{
                dev_err(&client->dev, "irq %d busy?\n", ts->irq);
                goto err_free_mem;
       }
 
        err = input_register_device(input_dev);
        if (err)
                goto err_free_irq;
 
        dev_info(&client->dev, "registered with irq (%d)\n", ts->irq);
 
        return 0;
 
	err_free_irq:
	       free_irq(ts->irq, ts);
	       hrtimer_cancel(&ts->timer);
	err_free_mem:
	       input_free_device(input_dev);
              kfree(ts);
              return err;
 }

static int tsc2007_remove(struct i2c_client *client)
{
         struct tsc2007  *ts = i2c_get_clientdata(client);
         struct tsc2007_platform_data *pdata;

         pdata = client->dev.platform_data;
         pdata->exit_platform_hw();
 
         free_irq(ts->irq, ts);
         hrtimer_cancel(&ts->timer);
         input_unregister_device(ts->input);
         kfree(ts);
 
         return 0;
 }
 
static struct i2c_device_id tsc2007_idtable[] = {{ "tsc2007", 0 }, { }};

MODULE_DEVICE_TABLE(i2c, tsc2007_idtable);

static struct i2c_driver tsc2007_driver = {
         .driver = {
		                .owner  = THIS_MODULE,
		                .name   = "tsc2007"
		         },
 	         .id_table       = tsc2007_idtable,/*with .driver, idicate the tsc2007 driver */
	         .attach_adapter = tsc2007_attach_adapter,/*just like attach_adapter,search a I2C bus and see whether device exist.If yes,bound to it and visit it via adapter*/
	         .remove         = tsc2007_remove,/*just like detach_client, disable the device */
 };
 
static int __init tsc2007_init(void)
{
       return i2c_add_driver(&tsc2007_driver);
}

static void __exit tsc2007_exit(void)
{
         i2c_del_driver(&tsc2007_driver);
 }

module_init(tsc2007_init);
module_exit(tsc2007_exit);
 
MODULE_AUTHOR("Creative.com<www.creative.com>");
MODULE_DESCRIPTION("TSC2007 TouchScreen Driver");
MODULE_LICENSE("GPL");