URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [input/] [touchscreen/] [hp680_ts_input.c] - Blame information for rev 62

Details | Compare with Previous | View Log


#include <linux/input.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <asm/io.h>
#include <asm/delay.h>
#include <asm/adc.h>
#include <asm/hp6xx.h>
 
#define MODNAME "hp680_ts_input"
 
#define HP680_TS_ABS_X_MIN      40
#define HP680_TS_ABS_X_MAX      950
#define HP680_TS_ABS_Y_MIN      80
#define HP680_TS_ABS_Y_MAX      910
 
#define PHDR    0xa400012e
#define SCPDR   0xa4000136
 
static void do_softint(struct work_struct *work);
 
static struct input_dev *hp680_ts_dev;
static DECLARE_DELAYED_WORK(work, do_softint);
 
static void do_softint(struct work_struct *work)
{
        int absx = 0, absy = 0;
        u8 scpdr;
        int touched = 0;
 
        if (ctrl_inb(PHDR) & PHDR_TS_PEN_DOWN) {
                scpdr = ctrl_inb(SCPDR);
                scpdr |= SCPDR_TS_SCAN_ENABLE;
                scpdr &= ~SCPDR_TS_SCAN_Y;
                ctrl_outb(scpdr, SCPDR);
                udelay(30);
 
                absy = adc_single(ADC_CHANNEL_TS_Y);
 
                scpdr = ctrl_inb(SCPDR);
                scpdr |= SCPDR_TS_SCAN_Y;
                scpdr &= ~SCPDR_TS_SCAN_X;
                ctrl_outb(scpdr, SCPDR);
                udelay(30);
 
                absx = adc_single(ADC_CHANNEL_TS_X);
 
                scpdr = ctrl_inb(SCPDR);
                scpdr |= SCPDR_TS_SCAN_X;
                scpdr &= ~SCPDR_TS_SCAN_ENABLE;
                ctrl_outb(scpdr, SCPDR);
                udelay(100);
                touched = ctrl_inb(PHDR) & PHDR_TS_PEN_DOWN;
        }
 
        if (touched) {
                input_report_key(hp680_ts_dev, BTN_TOUCH, 1);
                input_report_abs(hp680_ts_dev, ABS_X, absx);
                input_report_abs(hp680_ts_dev, ABS_Y, absy);
        } else {
                input_report_key(hp680_ts_dev, BTN_TOUCH, 0);
        }
 
        input_sync(hp680_ts_dev);
        enable_irq(HP680_TS_IRQ);
}
 
static irqreturn_t hp680_ts_interrupt(int irq, void *dev)
{
        disable_irq_nosync(irq);
        schedule_delayed_work(&work, HZ / 20);
 
        return IRQ_HANDLED;
}
 
static int __init hp680_ts_init(void)
{
        int err;
 
        hp680_ts_dev = input_allocate_device();
        if (!hp680_ts_dev)
                return -ENOMEM;
 
        hp680_ts_dev->evbit[0] = BIT_MASK(EV_ABS) | BIT_MASK(EV_KEY);
        hp680_ts_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
 
        input_set_abs_params(hp680_ts_dev, ABS_X,
                HP680_TS_ABS_X_MIN, HP680_TS_ABS_X_MAX, 0, 0);
        input_set_abs_params(hp680_ts_dev, ABS_Y,
                HP680_TS_ABS_Y_MIN, HP680_TS_ABS_Y_MAX, 0, 0);
 
        hp680_ts_dev->name = "HP Jornada touchscreen";
        hp680_ts_dev->phys = "hp680_ts/input0";
 
        if (request_irq(HP680_TS_IRQ, hp680_ts_interrupt,
                        IRQF_DISABLED, MODNAME, 0) < 0) {
                printk(KERN_ERR "hp680_touchscreen.c: Can't allocate irq %d\n",
                       HP680_TS_IRQ);
                err = -EBUSY;
                goto fail1;
        }
 
        err = input_register_device(hp680_ts_dev);
        if (err)
                goto fail2;
 
        return 0;
 
 fail2: free_irq(HP680_TS_IRQ, NULL);
        cancel_delayed_work(&work);
        flush_scheduled_work();
 fail1: input_free_device(hp680_ts_dev);
        return err;
}
 
static void __exit hp680_ts_exit(void)
{
        free_irq(HP680_TS_IRQ, NULL);
        cancel_delayed_work(&work);
        flush_scheduled_work();
        input_unregister_device(hp680_ts_dev);
}
 
module_init(hp680_ts_init);
module_exit(hp680_ts_exit);
 
MODULE_AUTHOR("Andriy Skulysh, askulysh@image.kiev.ua");
MODULE_DESCRIPTION("HP Jornada 680 touchscreen driver");
MODULE_LICENSE("GPL");

Line No.	Rev	Author	Line
1	62	marcus.erl	`#include <linux/input.h>`
2			`#include <linux/module.h>`
3			`#include <linux/init.h>`
4			`#include <linux/interrupt.h>`
5			`#include <asm/io.h>`
6			`#include <asm/delay.h>`
7			`#include <asm/adc.h>`
8			`#include <asm/hp6xx.h>`
9
10			`#define MODNAME "hp680_ts_input"`
11
12			`#define HP680_TS_ABS_X_MIN 40`
13			`#define HP680_TS_ABS_X_MAX 950`
14			`#define HP680_TS_ABS_Y_MIN 80`
15			`#define HP680_TS_ABS_Y_MAX 910`
16
17			`#define PHDR 0xa400012e`
18			`#define SCPDR 0xa4000136`
19
20			`static void do_softint(struct work_struct *work);`
21
22			`static struct input_dev *hp680_ts_dev;`
23			`static DECLARE_DELAYED_WORK(work, do_softint);`
24
25			`static void do_softint(struct work_struct *work)`
26			`{`
27			`int absx = 0, absy = 0;`
28			`u8 scpdr;`
29			`int touched = 0;`
30
31			`if (ctrl_inb(PHDR) & PHDR_TS_PEN_DOWN) {`
32			`scpdr = ctrl_inb(SCPDR);`
33			`scpdr \|= SCPDR_TS_SCAN_ENABLE;`
34			`scpdr &= ~SCPDR_TS_SCAN_Y;`
35			`ctrl_outb(scpdr, SCPDR);`
36			`udelay(30);`
37
38			`absy = adc_single(ADC_CHANNEL_TS_Y);`
39
40			`scpdr = ctrl_inb(SCPDR);`
41			`scpdr \|= SCPDR_TS_SCAN_Y;`
42			`scpdr &= ~SCPDR_TS_SCAN_X;`
43			`ctrl_outb(scpdr, SCPDR);`
44			`udelay(30);`
45
46			`absx = adc_single(ADC_CHANNEL_TS_X);`
47
48			`scpdr = ctrl_inb(SCPDR);`
49			`scpdr \|= SCPDR_TS_SCAN_X;`
50			`scpdr &= ~SCPDR_TS_SCAN_ENABLE;`
51			`ctrl_outb(scpdr, SCPDR);`
52			`udelay(100);`
53			`touched = ctrl_inb(PHDR) & PHDR_TS_PEN_DOWN;`
54			`}`
55
56			`if (touched) {`
57			`input_report_key(hp680_ts_dev, BTN_TOUCH, 1);`
58			`input_report_abs(hp680_ts_dev, ABS_X, absx);`
59			`input_report_abs(hp680_ts_dev, ABS_Y, absy);`
60			`} else {`
61			`input_report_key(hp680_ts_dev, BTN_TOUCH, 0);`
62			`}`
63
64			`input_sync(hp680_ts_dev);`
65			`enable_irq(HP680_TS_IRQ);`
66			`}`
67
68			`static irqreturn_t hp680_ts_interrupt(int irq, void *dev)`
69			`{`
70			`disable_irq_nosync(irq);`
71			`schedule_delayed_work(&work, HZ / 20);`
72
73			`return IRQ_HANDLED;`
74			`}`
75
76			`static int __init hp680_ts_init(void)`
77			`{`
78			`int err;`
79
80			`hp680_ts_dev = input_allocate_device();`
81			`if (!hp680_ts_dev)`
82			`return -ENOMEM;`
83
84			`hp680_ts_dev->evbit[0] = BIT_MASK(EV_ABS) \| BIT_MASK(EV_KEY);`
85			`hp680_ts_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);`
86
87			`input_set_abs_params(hp680_ts_dev, ABS_X,`
88			`HP680_TS_ABS_X_MIN, HP680_TS_ABS_X_MAX, 0, 0);`
89			`input_set_abs_params(hp680_ts_dev, ABS_Y,`
90			`HP680_TS_ABS_Y_MIN, HP680_TS_ABS_Y_MAX, 0, 0);`
91
92			`hp680_ts_dev->name = "HP Jornada touchscreen";`
93			`hp680_ts_dev->phys = "hp680_ts/input0";`
94
95			`if (request_irq(HP680_TS_IRQ, hp680_ts_interrupt,`
96			`IRQF_DISABLED, MODNAME, 0) < 0) {`
97			`printk(KERN_ERR "hp680_touchscreen.c: Can't allocate irq %d\n",`
98			`HP680_TS_IRQ);`
99			`err = -EBUSY;`
100			`goto fail1;`
101			`}`
102
103			`err = input_register_device(hp680_ts_dev);`
104			`if (err)`
105			`goto fail2;`
106
107			`return 0;`
108
109			`fail2: free_irq(HP680_TS_IRQ, NULL);`
110			`cancel_delayed_work(&work);`
111			`flush_scheduled_work();`
112			`fail1: input_free_device(hp680_ts_dev);`
113			`return err;`
114			`}`
115
116			`static void __exit hp680_ts_exit(void)`
117			`{`
118			`free_irq(HP680_TS_IRQ, NULL);`
119			`cancel_delayed_work(&work);`
120			`flush_scheduled_work();`
121			`input_unregister_device(hp680_ts_dev);`
122			`}`
123
124			`module_init(hp680_ts_init);`
125			`module_exit(hp680_ts_exit);`
126
127			`MODULE_AUTHOR("Andriy Skulysh, askulysh@image.kiev.ua");`
128			`MODULE_DESCRIPTION("HP Jornada 680 touchscreen driver");`
129			`MODULE_LICENSE("GPL");`

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [input/] [touchscreen/] [hp680_ts_input.c] - Blame information for rev 62