@@ -307,6 +307,18 @@
To compile this driver as a module, choose M here: the
module will be called atmel_tsadcc.
+config TOUCHSCREEN_S3C24XX_TSADCC
+ tristate "Samsung S3C24XX touchscreen input driver"
+ depends on ARCH_S3C2410 && S3C24XX_ADC && INPUT && INPUT_TOUCHSCREEN
+ help
+ Say Y here if you have a touchscreen connected to the ADC Controller
+ on your s3c2410/s3c2440 SoC.
+
+ If unsure, say N.
+
+ To compile this driver as a module, choose M here: the
+ module will be called s3c24xx_tsadcc.
+
config TOUCHSCREEN_UCB1400
tristate "Philips UCB1400 touchscreen"
depends on AC97_BUS
@@ -10,6 +10,7 @@
obj-$(CONFIG_TOUCHSCREEN_AD7879) += ad7879.o
obj-$(CONFIG_TOUCHSCREEN_ADS7846) += ads7846.o
obj-$(CONFIG_TOUCHSCREEN_ATMEL_TSADCC) += atmel_tsadcc.o
+obj-$(CONFIG_TOUCHSCREEN_S3C24XX_TSADCC) += s3c24xx_tsadcc.o
obj-$(CONFIG_TOUCHSCREEN_BITSY) += h3600_ts_input.o
obj-$(CONFIG_TOUCHSCREEN_CORGI) += corgi_ts.o
obj-$(CONFIG_TOUCHSCREEN_GUNZE) += gunze.o
@@ -0,0 +1,440 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Part of the code comes from the openmoko project.
+ *
+ * Shine Liu <shinel@foxmail.com>
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/input.h>
+#include <linux/timer.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/interrupt.h>
+
+#include <mach/regs-gpio.h>
+#include <mach/gpio.h>
+#include <plat/regs-adc.h>
+#include <plat/adc.h>
+
+
+MODULE_AUTHOR("Shine Liu <shinel@foxmail.com>");
+MODULE_DESCRIPTION("Samsung s3c24xx touchscreen driver");
+MODULE_LICENSE("GPL");
+
+
+#define S3C24XX_TS_VERSION 0x0101
+
+#define TSC_SLEEP (S3C2410_ADCTSC_PULL_UP_DISABLE | \
+ S3C2410_ADCTSC_XY_PST(0))
+
+#define WAIT4INT(x) (((x)<<8) | \
+ S3C2410_ADCTSC_YM_SEN | \
+ S3C2410_ADCTSC_YP_SEN | \
+ S3C2410_ADCTSC_XP_SEN | \
+ S3C2410_ADCTSC_XY_PST(3))
+
+#define AUTO_XY (S3C2410_ADCTSC_PULL_UP_DISABLE | \
+ S3C2410_ADCTSC_AUTO_PST | \
+ S3C2410_ADCTSC_XY_PST(0))
+
+#define TS_STATE_STANDBY 0 /* initial state */
+#define TS_STATE_PRESSED 1
+#define TS_STATE_RELEASE_PENDING 2 /* wait to confirm the up event */
+#define TS_STATE_RELEASE 3
+
+#define TIME_RELEASE_PENDING (HZ / 20) /* about 50ms */
+#define TIME_NEXT_CONV ((HZ < 50)? 1 : HZ / 50) /* about 20ms */
+
+static char *s3c24xx_ts_name = "Samsung s3c24xx TouchScreen";
+
+static void ts_drag_pull_timer_f(unsigned long data);
+
+
+/*
+ * Per-touchscreen data.
+ */
+
+struct s3c24xx_ts {
+ struct input_dev *input;
+ struct platform_device *pdev;
+ struct s3c_adc_client *adc_client;
+ void __iomem *base_addr;
+ struct timer_list drag_pull_timer;
+
+ unsigned char is_down;
+ unsigned char state;
+ unsigned adc_selected;
+ unsigned int delay; /* register value for delay */
+ unsigned int presc; /* register value for prescaler */
+};
+
+
+/*
+ * Low level functions to config registers.
+ */
+static inline void s3c24xx_ts_connect(void)
+{
+ s3c2410_gpio_cfgpin(S3C2410_GPG(12), S3C2410_GPG12_XMON);
+ s3c2410_gpio_cfgpin(S3C2410_GPG(13), S3C2410_GPG13_nXPON);
+ s3c2410_gpio_cfgpin(S3C2410_GPG(14), S3C2410_GPG14_YMON);
+ s3c2410_gpio_cfgpin(S3C2410_GPG(15), S3C2410_GPG15_nYPON);
+}
+
+static void s3c24xx_ts_start_adc_conversion(struct s3c24xx_ts *ts)
+{
+ dev_dbg(&ts->pdev->dev, "start_adc_conv ADCTSC: 0x%x",
+ readl(ts->base_addr + S3C2410_ADCTSC));
+ writel(AUTO_XY, ts->base_addr + S3C2410_ADCTSC);
+ dev_dbg(&ts->pdev->dev, " ---> 0x%x",
+ readl(ts->base_addr + S3C2410_ADCTSC));
+ s3c_adc_start(ts->adc_client, 0, 1);
+ dev_dbg(&ts->pdev->dev, " ---> 0x%x\n",
+ readl(ts->base_addr + S3C2410_ADCTSC));
+}
+
+
+/*
+ * Event handling
+ */
+
+enum ts_input_event {IE_UP = 0, IE_DOWN};
+
+static void ts_input_report(struct s3c24xx_ts *ts, int event, int coords[])
+{
+ if (event == IE_DOWN) {
+ input_report_abs(ts->input, ABS_X, coords[0]);
+ input_report_abs(ts->input, ABS_Y, coords[1]);
+ input_report_key(ts->input, BTN_TOUCH, 1);
+ dev_dbg(&ts->pdev->dev, "down (X:%03d, Y:%03d)\n",
+ coords[0], coords[1]);
+ } else {
+ input_report_key(ts->input, BTN_TOUCH, 0);
+ dev_dbg(&ts->pdev->dev, "up\n");
+ }
+
+ input_sync(ts->input);
+}
+
+
+/*
+ * Timer to process the UP event or to report the postion of DRAG
+ */
+
+static void ts_drag_pull_timer_f(unsigned long data)
+{
+ struct s3c24xx_ts *ts = (struct s3c24xx_ts *)data;
+
+ /* delay reporting the UP event to avoid jitter */
+ static unsigned release_pending_counter = 0;
+ dev_dbg(&ts->pdev->dev, "Timer called: is_down[%d] status[%d]\n",
+ ts->is_down, ts->state);
+
+ if(ts->state == TS_STATE_RELEASE_PENDING) {
+ if(release_pending_counter++ < 1) {
+ /* jitter avoidance: delay TIME_RELEASE_PENDING jfs */
+ mod_timer(&ts->drag_pull_timer,
+ jiffies + TIME_RELEASE_PENDING);
+ } else {
+ /* no down event occurd during last delay */
+ release_pending_counter = 0;
+ ts_input_report(ts, IE_UP, NULL);
+ ts->state = TS_STATE_RELEASE;
+ writel(WAIT4INT(0), ts->base_addr + S3C2410_ADCTSC);
+ }
+ return;
+ }
+
+ /* ts->is_down should be true here */
+ s3c24xx_ts_start_adc_conversion(ts);
+}
+
+
+/*
+ * ISR for the IRQ_TS
+ */
+
+static irqreturn_t stylus_updown(int irq, void *dev)
+{
+ unsigned long data0;
+ unsigned long data1;
+ unsigned long adctsc;
+ int event_type; /* 1 for down, 0 for up */
+
+ struct s3c24xx_ts *ts = dev;
+
+ /*
+ * According to s3c2440 manual chap16: After Touch Screen
+ * Controller generates INT_TC, XY_PST must be set to [00]
+ */
+ adctsc = readl(ts->base_addr + S3C2410_ADCTSC);
+ writel(adctsc & ~(S3C2410_ADCTSC_XY_PST(3)),
+ ts->base_addr + S3C2410_ADCTSC);
+ data0 = readl(ts->base_addr + S3C2410_ADCDAT0);
+ data1 = readl(ts->base_addr + S3C2410_ADCDAT1);
+ event_type = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) &&
+ (!(data1 & S3C2410_ADCDAT0_UPDOWN));
+ dev_dbg(&ts->pdev->dev, "event_type: %d, DATA0 0x%lx, DATA1 0x%lx,"
+ "ADCTSC 0x%lx, ADCUPDN 0x%x\n", event_type,
+ data0, data1, adctsc, readl(ts->base_addr + 0x14));
+
+ /* ignore sequential the same UP/DOWN event */
+ if(ts->is_down == event_type) {
+ dev_dbg(&ts->pdev->dev, "### Ignore the same UP/DOWN event: %d\n",
+ event_type);
+ /* restore XY_PST */
+ writel(adctsc, ts->base_addr + S3C2410_ADCTSC);
+ return IRQ_HANDLED;
+ }
+
+ ts->is_down = event_type;
+ if (ts->is_down) {
+ s3c24xx_ts_start_adc_conversion(ts);
+ } else {
+ ts->state = TS_STATE_RELEASE_PENDING;
+ /*
+ * Delay to report the up event for a while to avoid jitter.
+ * This state will be checked after (0, TIME_NEXT_CONV)
+ * jiffies depended on when the interrupt occured.
+ */
+ }
+
+ return IRQ_HANDLED;
+}
+
+
+/*
+ * Called in ISR of IRQ_ADC
+ */
+
+static void stylus_adc_action(struct s3c_adc_client *client,
+ unsigned p0, unsigned p1, unsigned *conv_left)
+{
+ int buf[2];
+ struct s3c24xx_ts *ts =
+ platform_get_drvdata(*(struct platform_device **)client);
+
+ /*
+ * IRQ_TS may rise just in the time window between AUTO_XY mode
+ * set and this pointer */
+ if(ts->state == TS_STATE_RELEASE_PENDING)
+ return;
+
+ /* Grab the ADC results. */
+ buf[0] = p0;
+ buf[1] = p1;
+
+ ts_input_report(ts, IE_DOWN, buf);
+ dev_dbg(&ts->pdev->dev, "[adc_selected: %d] ADCTSC: 0x%x",
+ ts->adc_selected, readl(ts->base_addr + S3C2410_ADCTSC));
+
+ writel(WAIT4INT(1), ts->base_addr + S3C2410_ADCTSC);
+ dev_dbg(&ts->pdev->dev ," ---> 0x%x\n",
+ readl(ts->base_addr + S3C2410_ADCTSC));
+
+ ts->state = TS_STATE_PRESSED;
+ mod_timer(&ts->drag_pull_timer, jiffies + TIME_NEXT_CONV);
+}
+
+
+/*
+ * callback function for s3c-adc
+ */
+
+void adc_selected_f(struct s3c_adc_client *client, unsigned selected)
+{
+ struct s3c24xx_ts *ts =
+ platform_get_drvdata(*(struct platform_device **)client);
+
+ ts->adc_selected = selected;
+}
+
+
+/*
+ * The functions for inserting/removing us as a module.
+ */
+
+static int __devinit s3c24xx_ts_probe(struct platform_device *pdev)
+{
+ struct input_dev *input_dev;
+ struct s3c24xx_ts *ts;
+ int err = -ENOMEM;
+ struct timer_list timer_tmp =
+ TIMER_INITIALIZER(ts_drag_pull_timer_f, 0, 0);
+
+ dev_info(&pdev->dev, "Starting\n");
+ dev_dbg(&pdev->dev, "Entering s3c24xx_ts_probe\n");
+
+ /* Configure GPIOs */
+ s3c24xx_ts_connect();
+
+ /* Initialise input stuff */
+ ts = kzalloc(sizeof(struct s3c24xx_ts), GFP_KERNEL);
+ if (ts == NULL) {
+ dev_err(&pdev->dev, "failed to allocate s3c24xx_ts\n");
+ return -ENOMEM;
+ }
+
+ ts->pdev = pdev;
+ memcpy(&ts->drag_pull_timer, &timer_tmp, sizeof(struct timer_list));
+ ts->drag_pull_timer.data = (unsigned long)ts;
+
+ ts->base_addr = ioremap(S3C2410_PA_ADC, 0x20);
+ if (ts->base_addr == NULL) {
+ dev_err(&pdev->dev, "Failed to remap register block\n");
+ err = -ENXIO;
+ goto err_out_kfree;
+ }
+ ts->presc = readl(ts->base_addr + S3C2410_ADCCON);
+ ts->delay = readl(ts->base_addr + S3C2410_ADCDLY);
+ dev_dbg(&pdev->dev, "platform data: ADCCON=%08x ADCDLY=%08x\n",
+ ts->presc, ts->delay);
+ writel(WAIT4INT(0), ts->base_addr + S3C2410_ADCTSC);
+
+ ts->adc_client =
+ s3c_adc_register(pdev, adc_selected_f, stylus_adc_action, 1);
+ if (IS_ERR(ts->adc_client)) {
+ dev_err(&pdev->dev,
+ "Unable to register s3c24xx_ts as s3c_adc client\n");
+ err = PTR_ERR(ts->adc_client);
+ goto err_out_iounmap;
+ }
+
+ input_dev = input_allocate_device();
+ if (!input_dev) {
+ dev_err(&pdev->dev, "Unable to allocate the input device\n");
+ err = -ENOMEM;
+ goto err_out_adc_release;
+ }
+ ts->input = input_dev;
+
+ ts->input->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+ ts->input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+ input_set_abs_params(ts->input, ABS_X, 0, 0x3FF, 0, 0);
+ input_set_abs_params(ts->input, ABS_Y, 0, 0x3FF, 0, 0);
+
+ ts->input->name = s3c24xx_ts_name;
+ ts->input->id.vendor = 0xBAAD;
+ ts->input->id.product = 0xF00D;
+ ts->input->id.version = S3C24XX_TS_VERSION;
+ ts->state = TS_STATE_STANDBY;
+
+ /* Get IRQ */
+ err = request_irq(IRQ_TC, stylus_updown, IRQF_SAMPLE_RANDOM,
+ "s3c24xx_ts_action", ts);
+ if (err < 0) {
+ dev_err(&pdev->dev, "Could not allocate ts IRQ_TC\n");
+ goto err_out_free_dev;
+ }
+
+ /* All went ok, so register to the input system */
+ err = input_register_device(ts->input);
+ if (err < 0) {
+ dev_err(&pdev->dev, "Unable to register to the input system\n");
+ goto err_out_free_irq;
+ }
+ platform_set_drvdata(pdev, ts);
+ return 0;
+
+err_out_free_irq:
+ free_irq(IRQ_TC, ts);
+err_out_free_dev:
+ input_free_device(ts->input);
+err_out_adc_release:
+ s3c_adc_release(ts->adc_client);
+err_out_iounmap:
+ iounmap(ts->base_addr);
+err_out_kfree:
+ kfree(ts);
+ return err;
+}
+
+static int __devexit s3c24xx_ts_remove(struct platform_device *pdev)
+{
+ struct s3c24xx_ts *ts = platform_get_drvdata(pdev);
+
+ free_irq(IRQ_TC, ts);
+ input_unregister_device(ts->input);
+ s3c_adc_release(ts->adc_client);
+ iounmap(ts->base_addr);
+ kfree(ts);
+ return 0;
+}
+
+#ifdef CONFIG_PM
+static int s3c24xx_ts_pm_suspend(struct device *dev)
+{
+ struct s3c24xx_ts *ts = dev_get_drvdata(dev);
+
+ disable_irq(IRQ_TC);
+ /* save prescale EN and VAL in the S3C2410_ADCCON register */
+ ts->presc = readl(ts->base_addr + S3C2410_ADCCON);
+ /* save value of S3C2410_ADCDLY register */
+ ts->delay = readl(ts->base_addr + S3C2410_ADCDLY);
+
+
+ writel(TSC_SLEEP, ts->base_addr + S3C2410_ADCTSC);
+ writel(ts->presc | S3C2410_ADCCON_STDBM, ts->base_addr + S3C2410_ADCCON);
+ return 0;
+}
+
+static int s3c24xx_ts_pm_resume(struct device *dev)
+{
+ struct s3c24xx_ts *ts = dev_get_drvdata(dev);
+
+ /* Restore registers */
+ writel(ts->presc, ts->base_addr + S3C2410_ADCCON);
+ writel(ts->delay, ts->base_addr + S3C2410_ADCDLY);
+ writel(WAIT4INT(0), ts->base_addr + S3C2410_ADCTSC);
+ enable_irq(IRQ_TC);
+ return 0;
+}
+
+static struct dev_pm_ops s3c24xx_ts_pm_ops = {
+ .suspend = s3c24xx_ts_pm_suspend,
+ .resume = s3c24xx_ts_pm_resume,
+};
+
+#else
+#define s3c24xx_ts_pm_ops NULL
+#endif
+
+
+
+static struct platform_driver s3c24xx_ts_driver = {
+ .probe = s3c24xx_ts_probe,
+ .remove = __devexit_p(s3c24xx_ts_remove),
+ .driver = {
+ .name = "s3c24xx-ts",
+ .owner = THIS_MODULE,
+ .pm = s3c24xx_ts_pm_ops,
+ },
+};
+
+static int __init s3c24xx_ts_init(void)
+{
+ return platform_driver_register(&s3c24xx_ts_driver);
+}
+
+static void __exit s3c24xx_ts_exit(void)
+{
+ platform_driver_unregister(&s3c24xx_ts_driver);
+}
+
+module_init(s3c24xx_ts_init);
+module_exit(s3c24xx_ts_exit);
+