/* * intel_mid_touch.c - Intel MID Resistive Touch Screen Driver * * Copyright (C) 2008 Intel Corp * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * * 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; version 2 of the License. * * 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; ifnot, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. * * Questions/Comments/Bug fixes to Sreedhara (sreedhara.ds@intel.com) * Ramesh Agarwal (ramesh.agarwal@intel.com) * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * * TODO: * kill off mrstouch_debug eventually * review conversion of r/m/w sequences * Replace interrupt mutex abuse * Kill of mrstouchdevp pointer * */ #include #include #include #include #include #include #include #include #include #include #include #if defined(MRSTOUCH_DEBUG) #define mrstouch_debug(fmt, args...)\ do { \ printk(KERN_DEBUG "\n[MRSTOUCH(%d)] - ", __LINE__); \ printk(KERN_DEBUG fmt, ##args); \ } while (0); #else #define mrstouch_debug(fmt, args...) #endif /* PMIC Interrupt registers */ #define PMIC_REG_ID1 0x00 /*PMIC ID1 register */ /* PMIC Interrupt registers */ #define PMIC_REG_INT 0x04 /*PMIC interrupt register */ #define PMIC_REG_MINT 0x05 /*PMIC interrupt mask register */ /* ADC Interrupt registers */ #define PMIC_REG_ADCINT 0x5F /*ADC interrupt register */ #define PMIC_REG_MADCINT 0x60 /*ADC interrupt mask register */ /* ADC Control registers */ #define PMIC_REG_ADCCNTL1 0x61 /*ADC control register */ /* ADC Channel Selection registers */ #define PMICADDR0 0xA4 #define END_OF_CHANNEL 0x1F /* ADC Result register */ #define PMIC_REG_ADCSNS0H 0x64 /* ADC channels for touch screen */ #define MRST_TS_CHAN10 0xA /* Touch screen X+ connection */ #define MRST_TS_CHAN11 0xB /* Touch screen X- connection */ #define MRST_TS_CHAN12 0xC /* Touch screen Y+ connection */ #define MRST_TS_CHAN13 0xD /* Touch screen Y- connection */ /* Touch screen coordinate constants */ #define TOUCH_PRESSURE 50 #define TOUCH_PRESSURE_FS 100 #define XMOVE_LIMIT 5 #define YMOVE_LIMIT 5 #define XYMOVE_CNT 3 #define MAX_10BIT ((1<<10)-1) /* Touch screen channel BIAS constants */ #define XBIAS 0x20 #define YBIAS 0x40 #define ZBIAS 0x80 /* Touch screen coordinates */ #define MIN_X 10 #define MAX_X 1024 #define MIN_Y 10 #define MAX_Y 1024 #define WAIT_ADC_COMPLETION 10 /* PMIC ADC round robin delays */ #define ADC_LOOP_DELAY0 0x0 /* Continuous loop */ #define ADC_LOOP_DELAY1 0x1 /* 4.5 ms approximate */ /* PMIC Vendor Identifiers */ #define PMIC_VENDOR_FS 0 /* PMIC vendor FreeScale */ #define PMIC_VENDOR_MAXIM 1 /* PMIC vendor MAXIM */ #define PMIC_VENDOR_NEC 2 /* PMIC vendor NEC */ #define MRSTOUCH_MAX_CHANNELS 32 /* Maximum ADC channels */ /* Touch screen device structure */ struct mrstouch_dev { struct spi_device *spi; /* SPI device associated with touch screen */ struct input_dev *input; /* input device for touchscreen*/ char phys[32]; /* Device name */ struct task_struct *pendet_thrd; /* PENDET interrupt handler */ struct mutex lock; /* Sync between interrupt and PENDET handler */ bool busy; /* Busy flag */ u16 asr; /* Address selection register */ int irq; /* Touch screen IRQ # */ uint vendor; /* PMIC vendor */ uint rev; /* PMIC revision */ bool suspended; /* Device suspended status */ bool disabled; /* Device disabled status */ u16 x; /* X coordinate */ u16 y; /* Y coordinate */ bool pendown; /* PEN position */ } ; /* Global Pointer to Touch screen device */ static struct mrstouch_dev *mrstouchdevp; /* Utility to read PMIC ID */ static int mrstouch_pmic_id(uint *vendor, uint *rev) { int err; u8 r; err = intel_scu_ipc_ioread8(PMIC_REG_ID1, &r); if (err) return err; *vendor = r & 0x7; *rev = (r >> 3) & 0x7; return 0; } /* * Parse ADC channels to find end of the channel configured by other ADC user * NEC and MAXIM requires 4 channels and FreeScale needs 18 channels */ static int mrstouch_chan_parse(struct mrstouch_dev *tsdev) { int err, i, j, found; u32 r32; found = -1; for (i = 0; i < MRSTOUCH_MAX_CHANNELS; i++) { if (found >= 0) break; err = intel_scu_ipc_ioread32(PMICADDR0, &r32); if (err) return err; for (j = 0; j < 32; j+= 8) { if (((r32 >> j) & 0xFF) == END_OF_CHANNEL) { found = i; break; } } } if (found < 0) return 0; if (tsdev->vendor == PMIC_VENDOR_FS) { if (found && found > (MRSTOUCH_MAX_CHANNELS - 18)) return -ENOSPC; } else { if (found && found > (MRSTOUCH_MAX_CHANNELS - 4)) return -ENOSPC; } return found; } /* Utility to enable/disable pendet. * pendet set to true enables PENDET interrupt * pendet set to false disables PENDET interrupt * Also clears RND mask bit */ static int pendet_enable(struct mrstouch_dev *tsdev, bool pendet) { u16 reg; u8 r; u8 pendet_enabled = 0; int retry = 0; int err; err = intel_scu_ipc_ioread16(PMIC_REG_MADCINT, ®); if (err) return err; if (pendet) { reg &= ~0x0005; reg |= 0x2000; /* Enable pendet */ } else reg &= 0xDFFF; /* Disable pendet */ /* Set MADCINT and update ADCCNTL1 (next reg byte) */ err = intel_scu_ipc_iowrite16(PMIC_REG_MADCINT, reg); if (!pendet || err) return err; /* * Sometimes even after the register write succeeds * the PMIC register value is not updated. Retry few iterations * to enable pendet. */ err = intel_scu_ipc_ioread8(PMIC_REG_ADCCNTL1, &r); pendet_enabled = (r >> 5) & 0x01; retry = 0; while (!err && !pendet_enabled) { retry++; msleep(10); err = intel_scu_ipc_iowrite8(PMIC_REG_ADCCNTL1, reg >> 8); if (err) break; err = intel_scu_ipc_ioread8(PMIC_REG_ADCCNTL1, &r); if (err == 0) pendet_enabled = (r >> 5) & 0x01; if (retry >= 10) { dev_err(&tsdev->spi->dev, "Touch screen disabled.\n"); return -EIO; } } return 0; } /* To read PMIC ADC touch screen result * Reads ADC storage registers for higher 7 and lower 3 bits * converts the two readings to single value and turns off gain bit */ static int mrstouch_ts_chan_read(u16 offset, u16 chan, u16 *vp, u16 *vm) { int err; u16 result; u32 res; result = PMIC_REG_ADCSNS0H + offset; if (chan == MRST_TS_CHAN12) result += 4; err = intel_scu_ipc_ioread32(result, &res); if (err) return err; /* Mash the bits up */ *vp = (res & 0xFF) << 3; /* Highest 7 bits */ *vp |= (res >> 8) & 0x07; /* Lower 3 bits */ *vp &= 0x3FF; res >>= 16; *vm = (res & 0xFF) << 3; /* Highest 7 bits */ *vm |= (res >> 8) & 0x07; /* Lower 3 bits */ *vm &= 0x3FF; return 0; } /* To configure touch screen channels * Writes touch screen channels to ADC address selection registers */ static int mrstouch_ts_chan_set(uint offset) { int count; u16 chan; u16 reg[5]; u8 data[5]; chan = PMICADDR0 + offset; for (count = 0; count <= 3; count++) { reg[count] = chan++; data[count] = MRST_TS_CHAN10 + count; } reg[count] = chan; data[count] = END_OF_CHANNEL; return intel_scu_ipc_writev(reg, data, 5); } /* Initialize ADC */ static int mrstouch_adc_init(struct mrstouch_dev *tsdev) { int err, start; u8 ra, rm; err = mrstouch_pmic_id(&tsdev->vendor, &tsdev->rev); if (err) { dev_err(&tsdev->spi->dev, "Unable to read PMIC id\n"); return err; } start = mrstouch_chan_parse(tsdev); if (start < 0) { dev_err(&tsdev->spi->dev, "Unable to parse channels\n"); return start; } tsdev->asr = start; mrstouch_debug("Channel offset(%d): 0x%X\n", tsdev->asr, tsdev->vendor); /* ADC power on, start, enable PENDET and set loop delay * ADC loop delay is set to 4.5 ms approximately * Loop delay more than this results in jitter in adc readings * Setting loop delay to 0 (continous loop) in MAXIM stops PENDET * interrupt generation sometimes. */ if (tsdev->vendor == PMIC_VENDOR_FS) { ra = 0xE0 | ADC_LOOP_DELAY0; rm = 0x5; } else { /* NEC and MAXIm not consistent with loop delay 0 */ ra = 0xE0 | ADC_LOOP_DELAY1; rm = 0x0; /* configure touch screen channels */ err = mrstouch_ts_chan_set(tsdev->asr); if (err) return err; } err = intel_scu_ipc_update_register(PMIC_REG_ADCCNTL1, ra, 0xE7); if (err == 0) err = intel_scu_ipc_update_register(PMIC_REG_MADCINT, rm, 0x03); return err; } /* Reports x,y coordinates to event subsystem */ static void mrstouch_report_xy(struct mrstouch_dev *tsdev, u16 x, u16 y, u16 z) { int xdiff, ydiff; if (tsdev->pendown && z <= TOUCH_PRESSURE) { /* Pen removed, report button release */ mrstouch_debug("BTN REL(%d)", z); input_report_key(tsdev->input, BTN_TOUCH, 0); tsdev->pendown = false; } xdiff = abs(x - tsdev->x); ydiff = abs(y - tsdev->y); /* if x and y values changes for XYMOVE_CNT readings it is considered as stylus is moving. This is required to differentiate between stylus movement and jitter */ if (x < MIN_X || x > MAX_X || y < MIN_Y || y > MAX_Y) { /* Spurious values, release button if touched and return */ if (tsdev->pendown) { mrstouch_debug("BTN REL(%d)", z); input_report_key(tsdev->input, BTN_TOUCH, 0); tsdev->pendown = false; } return; } else if (xdiff >= XMOVE_LIMIT || ydiff >= YMOVE_LIMIT) { tsdev->x = x; tsdev->y = y; input_report_abs(tsdev->input, ABS_X, x); input_report_abs(tsdev->input, ABS_Y, y); input_sync(tsdev->input); } if (!tsdev->pendown && z > TOUCH_PRESSURE) { /* Pen touched, report button touch */ mrstouch_debug("BTN TCH(%d, %d, %d)", x, y, z); input_report_key(tsdev->input, BTN_TOUCH, 1); tsdev->pendown = true; } } /* Utility to start ADC, used by freescale handler */ static int pendet_mask(void) { return intel_scu_ipc_update_register(PMIC_REG_MADCINT, 0x02, 0x02); } /* Utility to stop ADC, used by freescale handler */ static int pendet_umask(void) { return intel_scu_ipc_update_register(PMIC_REG_MADCINT, 0x00, 0x02); } /* Utility to read ADC, used by freescale handler */ static int mrstouch_pmic_fs_adc_read(struct mrstouch_dev *tsdev) { int err; u16 x, y, z, result; u16 reg[4]; u8 data[4]; result = PMIC_REG_ADCSNS0H + tsdev->asr; reg[0] = result + 4; reg[1] = result + 5; reg[2] = result + 16; reg[3] = result + 17; err = intel_scu_ipc_readv(reg, data, 4); if (err) goto ipc_error; x = data[0] << 3; /* Higher 7 bits */ x |= data[1] & 0x7; /* Lower 3 bits */ x &= 0x3FF; y = data[2] << 3; /* Higher 7 bits */ y |= data[3] & 0x7; /* Lower 3 bits */ y &= 0x3FF; /* Read Z value */ reg[0] = result + 28; reg[1] = result + 29; err = intel_scu_ipc_readv(reg, data, 4); if (err) goto ipc_error; z = data[0] << 3; /* Higher 7 bits */ z |= data[1] & 0x7; /* Lower 3 bits */ z &= 0x3FF; #if defined(MRSTOUCH_PRINT_XYZP) mrstouch_debug("X: %d, Y: %d, Z: %d", x, y, z); #endif if (z >= TOUCH_PRESSURE_FS) { mrstouch_report_xy(tsdev, x, y, TOUCH_PRESSURE - 1); /* Pen Removed */ return TOUCH_PRESSURE - 1; } else { mrstouch_report_xy(tsdev, x, y, TOUCH_PRESSURE + 1); /* Pen Touched */ return TOUCH_PRESSURE + 1; } return 0; ipc_error: dev_err(&tsdev->spi->dev, "ipc error during fs_adc read\n"); return err; } /* To handle free scale pmic pendet interrupt */ static int pmic0_pendet(void *dev_id) { int err, count; u16 chan; unsigned int touched; struct mrstouch_dev *tsdev = (struct mrstouch_dev *)dev_id; u16 reg[5]; u8 data[5]; chan = PMICADDR0 + tsdev->asr; /* Set X BIAS */ for (count = 0; count <= 3; count++) { reg[count] = chan++; data[count] = 0x2A; } reg[count] = chan++; /* Dummy */ data[count] = 0; err = intel_scu_ipc_writev(reg, data, 5); if (err) goto ipc_error; msleep(WAIT_ADC_COMPLETION); /* Set Y BIAS */ for (count = 0; count <= 3; count++) { reg[count] = chan++; data[count] = 0x4A; } reg[count] = chan++; /* Dummy */ data[count] = 0; err = intel_scu_ipc_writev(reg, data, 5); if (err) goto ipc_error; msleep(WAIT_ADC_COMPLETION); /* Set Z BIAS */ err = intel_scu_ipc_iowrite32(chan + 2, 0x8A8A8A8A); if (err) goto ipc_error; msleep(WAIT_ADC_COMPLETION); /*Read touch screen channels till pen removed * Freescale reports constant value of z for all points * z is high when screen is not touched and low when touched * Map high z value to not touched and low z value to pen touched */ touched = mrstouch_pmic_fs_adc_read(tsdev); while (touched > TOUCH_PRESSURE) { touched = mrstouch_pmic_fs_adc_read(tsdev); msleep(WAIT_ADC_COMPLETION); } /* Clear all TS channels */ chan = PMICADDR0 + tsdev->asr; for (count = 0; count <= 4; count++) { reg[count] = chan++; data[count] = 0; } err = intel_scu_ipc_writev(reg, data, 5); if (err) goto ipc_error; for (count = 0; count <= 4; count++) { reg[count] = chan++; data[count] = 0; } err = intel_scu_ipc_writev(reg, data, 5); if (err) goto ipc_error; err = intel_scu_ipc_iowrite32(chan + 2, 0x00000000); if (err) goto ipc_error; return 0; ipc_error: dev_err(&tsdev->spi->dev, "ipc error during pendet\n"); return err; } /* To enable X, Y and Z bias values * Enables YPYM for X channels and XPXM for Y channels */ static int mrstouch_ts_bias_set(uint offset, uint bias) { int count; u16 chan, start; u16 reg[4]; u8 data[4]; chan = PMICADDR0 + offset; start = MRST_TS_CHAN10; for (count = 0; count <= 3; count++) { reg[count] = chan++; data[count] = bias | (start + count); } return intel_scu_ipc_writev(reg, data, 4); } /* To read touch screen channel values */ static int mrstouch_adc_read(struct mrstouch_dev *tsdev) { int err; u16 xp, xm, yp, ym, zp, zm; /* configure Y bias for X channels */ err = mrstouch_ts_bias_set(tsdev->asr, YBIAS); if (err) goto ipc_error; msleep(WAIT_ADC_COMPLETION); /* read x+ and x- channels */ err = mrstouch_ts_chan_read(tsdev->asr, MRST_TS_CHAN10, &xp, &xm); if (err) goto ipc_error; /* configure x bias for y channels */ err = mrstouch_ts_bias_set(tsdev->asr, XBIAS); if (err) goto ipc_error; msleep(WAIT_ADC_COMPLETION); /* read y+ and y- channels */ err = mrstouch_ts_chan_read(tsdev->asr, MRST_TS_CHAN12, &yp, &ym); if (err) goto ipc_error; /* configure z bias for x and y channels */ err = mrstouch_ts_bias_set(tsdev->asr, ZBIAS); if (err) goto ipc_error; msleep(WAIT_ADC_COMPLETION); /* read z+ and z- channels */ err = mrstouch_ts_chan_read(tsdev->asr, MRST_TS_CHAN10, &zp, &zm); if (err) goto ipc_error; #if defined(MRSTOUCH_PRINT_XYZP) printk(KERN_INFO "X+: %d, Y+: %d, Z+: %d\n", xp, yp, zp); #endif #if defined(MRSTOUCH_PRINT_XYZM) printk(KERN_INFO "X-: %d, Y-: %d, Z-: %d\n", xm, ym, zm); #endif mrstouch_report_xy(tsdev, xp, yp, zp); /* report x and y to eventX */ return zp; ipc_error: dev_err(&tsdev->spi->dev, "ipc error during adc read\n"); return err; } /* PENDET interrupt handler function for NEC and MAXIM */ static void pmic12_pendet(void *data) { unsigned int touched; struct mrstouch_dev *tsdev = (struct mrstouch_dev *)data; /* read touch screen channels till pen removed */ do { touched = mrstouch_adc_read(tsdev); } while (touched > TOUCH_PRESSURE); } /* Handler to process PENDET interrupt */ int mrstouch_pendet(void *data) { struct mrstouch_dev *tsdev = (struct mrstouch_dev *)data; while (1) { /* Wait for PENDET interrupt */ if (mutex_lock_interruptible(&tsdev->lock)) { msleep(WAIT_ADC_COMPLETION); continue; } if (tsdev->busy) return 0; tsdev->busy = true; if (tsdev->vendor == PMIC_VENDOR_NEC || tsdev->vendor == PMIC_VENDOR_MAXIM) { /* PENDET must be disabled in NEC before reading ADC */ pendet_enable(tsdev,false); /* Disbale PENDET */ pmic12_pendet(tsdev); pendet_enable(tsdev, true); /*Enable PENDET */ } else if (tsdev->vendor == PMIC_VENDOR_FS) { pendet_umask(); /* Stop ADC */ pmic0_pendet(tsdev); pendet_mask(); /* Stop ADC */ } else dev_err(&tsdev->spi->dev, "Unsupported touchscreen: %d\n", tsdev->vendor); tsdev->busy = false; } return 0; } /* PENDET interrupt handler */ static irqreturn_t pendet_intr_handler(int irq, void *handle) { struct mrstouch_dev *tsdev = (struct mrstouch_dev *)handle; mutex_unlock(&tsdev->lock); return IRQ_HANDLED; } /* Intializes input device and registers with input subsystem */ static int ts_input_dev_init(struct mrstouch_dev *tsdev, struct spi_device *spi) { int err = 0; mrstouch_debug("%s", __func__); tsdev->input = input_allocate_device(); if (!tsdev->input) { dev_err(&tsdev->spi->dev, "Unable to allocate input device.\n"); return -EINVAL; } tsdev->input->name = "mrst_touchscreen"; snprintf(tsdev->phys, sizeof(tsdev->phys), "%s/input0", dev_name(&spi->dev)); tsdev->input->phys = tsdev->phys; tsdev->input->dev.parent = &spi->dev; tsdev->input->id.vendor = tsdev->vendor; tsdev->input->id.version = tsdev->rev; tsdev->input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); tsdev->input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); input_set_abs_params(tsdev->input, ABS_X, MIN_X, MIN_Y, 0, 0); input_set_abs_params(tsdev->input, ABS_Y, MIN_X, MIN_Y, 0, 0); err = input_register_device(tsdev->input); if (err) { dev_err(&tsdev->spi->dev, "unable to register input device\n"); input_free_device(tsdev->input); return err; } mrstouch_debug("%s", "mrstouch initialized"); return 0; } /* Probe function for touch screen driver */ static int __devinit mrstouch_probe(struct spi_device *mrstouch_spi) { int err; unsigned int myirq; struct mrstouch_dev *tsdev; mrstouch_debug("%s(%p)", __func__, mrstouch_spi); mrstouchdevp = NULL; myirq = mrstouch_spi->irq; if (!mrstouch_spi->irq) { dev_err(&mrstouch_spi->dev, "no interrupt assigned\n"); return -EINVAL; } tsdev = kzalloc(sizeof(struct mrstouch_dev), GFP_KERNEL); if (!tsdev) { dev_err(&mrstouch_spi->dev, "unable to allocate memory\n"); return -ENOMEM; } tsdev->irq = myirq; mrstouchdevp = tsdev; err = mrstouch_adc_init(tsdev); if (err) { dev_err(&mrstouch_spi->dev, "ADC init failed\n"); goto mrstouch_err_free_mem; } dev_set_drvdata(&mrstouch_spi->dev, tsdev); tsdev->spi = mrstouch_spi; err = ts_input_dev_init(tsdev, mrstouch_spi); if (err) { dev_err(&tsdev->spi->dev, "ts_input_dev_init failed"); goto mrstouch_err_free_mem; } mutex_init(&tsdev->lock); mutex_lock(&tsdev->lock) mrstouch_debug("Requesting IRQ-%d", myirq); err = request_irq(myirq, pendet_intr_handler, 0, "mrstouch", tsdev); if (err) { dev_err(&tsdev->spi->dev, "unable to allocate irq\n"); goto mrstouch_err_free_mem; } tsdev->pendet_thrd = kthread_run(mrstouch_pendet, (void *)tsdev, "pendet handler"); if (IS_ERR(tsdev->pendet_thrd)) { dev_err(&tsdev->spi->dev, "kthread_run failed\n"); err = PTR_ERR(tsdev->pendet_thrd); goto mrstouch_err_free_mem; } mrstouch_debug("%s", "Driver initialized"); return 0; mrstouch_err_free_mem: kfree(tsdev); return err; } static int mrstouch_suspend(struct spi_device *spi, pm_message_t msg) { mrstouch_debug("%s", __func__); mrstouchdevp->suspended = 1; return 0; } static int mrstouch_resume(struct spi_device *spi) { mrstouch_debug("%s", __func__); mrstouchdevp->suspended = 0; return 0; } static int mrstouch_remove(struct spi_device *spi) { mrstouch_debug("%s", __func__); free_irq(mrstouchdevp->irq, mrstouchdevp); input_unregister_device(mrstouchdevp->input); input_free_device(mrstouchdevp->input); if (mrstouchdevp->pendet_thrd) kthread_stop(mrstouchdevp->pendet_thrd); kfree(mrstouchdevp); return 0; } static struct spi_driver mrstouch_driver = { .driver = { .name = "pmic_touch", .bus = &spi_bus_type, .owner = THIS_MODULE, }, .probe = mrstouch_probe, .suspend = mrstouch_suspend, .resume = mrstouch_resume, .remove = mrstouch_remove, }; static int __init mrstouch_module_init(void) { int err; mrstouch_debug("%s", __func__); err = spi_register_driver(&mrstouch_driver); if (err) { mrstouch_debug("%s(%d)", "SPI PENDET failed", err); return -1; } return 0; } static void __exit mrstouch_module_exit(void) { mrstouch_debug("%s", __func__); spi_unregister_driver(&mrstouch_driver); return; } module_init(mrstouch_module_init); module_exit(mrstouch_module_exit); MODULE_AUTHOR("Sreedhara Murthy. D.S, sreedhara.ds@intel.com"); MODULE_DESCRIPTION("Intel Moorestown Resistive Touch Screen Driver"); MODULE_LICENSE("GPL");