]> git.openfabrics.org - ~shefty/rdma-dev.git/commitdiff
Merge commit 'v2.6.31-rc4' into next
authorDmitry Torokhov <dmitry.torokhov@gmail.com>
Thu, 23 Jul 2009 04:47:29 +0000 (21:47 -0700)
committerDmitry Torokhov <dmitry.torokhov@gmail.com>
Thu, 23 Jul 2009 04:47:29 +0000 (21:47 -0700)
12 files changed:
drivers/input/keyboard/sh_keysc.c
drivers/input/misc/cobalt_btns.c
drivers/input/misc/dm355evm_keys.c
drivers/input/serio/at32psif.c
drivers/input/touchscreen/Kconfig
drivers/input/touchscreen/atmel_tsadcc.c
drivers/input/touchscreen/mainstone-wm97xx.c
drivers/input/touchscreen/ucb1400_ts.c
drivers/input/touchscreen/usbtouchscreen.c
drivers/input/touchscreen/w90p910_ts.c
drivers/input/touchscreen/wm97xx-core.c
include/linux/wm97xx.h

index cea70e6a1031a12d91346756b7fec83faab1324f..0714bf2c28fcb513a22c8c17a288e4b8b7a85735 100644 (file)
@@ -128,7 +128,7 @@ static int __devinit sh_keysc_probe(struct platform_device *pdev)
        struct resource *res;
        struct input_dev *input;
        char clk_name[8];
-       int i, k;
+       int i;
        int irq, error;
 
        if (!pdev->dev.platform_data) {
@@ -195,17 +195,19 @@ static int __devinit sh_keysc_probe(struct platform_device *pdev)
        input->id.product = 0x0001;
        input->id.version = 0x0100;
 
+       input->keycode = pdata->keycodes;
+       input->keycodesize = sizeof(pdata->keycodes[0]);
+       input->keycodemax = ARRAY_SIZE(pdata->keycodes);
+
        error = request_irq(irq, sh_keysc_isr, 0, pdev->name, pdev);
        if (error) {
                dev_err(&pdev->dev, "failed to request IRQ\n");
                goto err4;
        }
 
-       for (i = 0; i < SH_KEYSC_MAXKEYS; i++) {
-               k = pdata->keycodes[i];
-               if (k)
-                       input_set_capability(input, EV_KEY, k);
-       }
+       for (i = 0; i < SH_KEYSC_MAXKEYS; i++)
+               __set_bit(pdata->keycodes[i], input->keybit);
+       __clear_bit(KEY_RESERVED, input->keybit);
 
        error = input_register_device(input);
        if (error) {
@@ -221,7 +223,9 @@ static int __devinit sh_keysc_probe(struct platform_device *pdev)
        iowrite16(KYCR2_IRQ_LEVEL, priv->iomem_base + KYCR2_OFFS);
 
        device_init_wakeup(&pdev->dev, 1);
+
        return 0;
+
  err5:
        free_irq(irq, pdev);
  err4:
@@ -252,6 +256,7 @@ static int __devexit sh_keysc_remove(struct platform_device *pdev)
 
        platform_set_drvdata(pdev, NULL);
        kfree(priv);
+
        return 0;
 }
 
@@ -267,11 +272,12 @@ static int sh_keysc_suspend(struct device *dev)
        if (device_may_wakeup(dev)) {
                value |= 0x80;
                enable_irq_wake(irq);
-       }
-       else
+       } else {
                value &= ~0x80;
+       }
 
        iowrite16(value, priv->iomem_base + KYCR1_OFFS);
+
        return 0;
 }
 
index d114d3a9e1e94b7129870642943d7ac91a368cac..ee73d7219c9280c6be1a3e3c7b4c82d6ef4a0b72 100644 (file)
@@ -116,7 +116,7 @@ static int __devinit cobalt_buttons_probe(struct platform_device *pdev)
        }
 
        bdev->poll_dev = poll_dev;
-       bdev->reg = ioremap(res->start, res->end - res->start + 1);
+       bdev->reg = ioremap(res->start, resource_size(res));
        dev_set_drvdata(&pdev->dev, bdev);
 
        error = input_register_polled_device(poll_dev);
index a63315ce4a6c7920eccb559867725f60334592bb..0918acae584ac9844d2dd64c500f235b56f22b72 100644 (file)
  * pressed, or its autorepeat kicks in, an event is sent.  This driver
  * read those events from the small (32 event) queue and reports them.
  *
- * Because we communicate with the MSP430 using I2C, and all I2C calls
- * in Linux sleep, we need to cons up a kind of threaded IRQ handler
- * using a work_struct.  The IRQ is active low, but we use it through
- * the GPIO controller so we can trigger on falling edges.
- *
  * Note that physically there can only be one of these devices.
  *
  * This driver was tested with firmware revision A4.
  */
 struct dm355evm_keys {
-       struct work_struct      work;
        struct input_dev        *input;
        struct device           *dev;
        int                     irq;
 };
 
-static irqreturn_t dm355evm_keys_irq(int irq, void *_keys)
-{
-       struct dm355evm_keys    *keys = _keys;
-
-       schedule_work(&keys->work);
-       return IRQ_HANDLED;
-}
-
 /* These initial keycodes can be remapped by dm355evm_setkeycode(). */
 static struct {
        u16     event;
@@ -110,13 +96,12 @@ static struct {
        { 0x3169, KEY_PAUSE, },
 };
 
-static void dm355evm_keys_work(struct work_struct *work)
+/* runs in an IRQ thread -- can (and will!) sleep */
+static irqreturn_t dm355evm_keys_irq(int irq, void *_keys)
 {
-       struct dm355evm_keys    *keys;
+       struct dm355evm_keys    *keys = _keys;
        int                     status;
 
-       keys = container_of(work, struct dm355evm_keys, work);
-
        /* For simplicity we ignore INPUT_COUNT and just read
         * events until we get the "queue empty" indicator.
         * Reading INPUT_LOW decrements the count.
@@ -183,6 +168,19 @@ static void dm355evm_keys_work(struct work_struct *work)
                input_report_key(keys->input, keycode, 0);
                input_sync(keys->input);
        }
+       return IRQ_HANDLED;
+}
+
+/*
+ * Because we communicate with the MSP430 using I2C, and all I2C calls
+ * in Linux sleep, we use a threaded IRQ handler.  The IRQ itself is
+ * active low, but we go through the GPIO controller so we can trigger
+ * on falling edges and not worry about enabling/disabling the IRQ in
+ * the keypress handling path.
+ */
+static irqreturn_t dm355evm_keys_hardirq(int irq, void *_keys)
+{
+       return IRQ_WAKE_THREAD;
 }
 
 static int dm355evm_setkeycode(struct input_dev *dev, int index, int keycode)
@@ -233,7 +231,6 @@ static int __devinit dm355evm_keys_probe(struct platform_device *pdev)
 
        keys->dev = &pdev->dev;
        keys->input = input;
-       INIT_WORK(&keys->work, dm355evm_keys_work);
 
        /* set up "threaded IRQ handler" */
        status = platform_get_irq(pdev, 0);
@@ -260,9 +257,10 @@ static int __devinit dm355evm_keys_probe(struct platform_device *pdev)
 
        /* REVISIT:  flush the event queue? */
 
-       status = request_irq(keys->irq, dm355evm_keys_irq,
-                            IRQF_TRIGGER_FALLING,
-                            dev_name(&pdev->dev), keys);
+       status = request_threaded_irq(keys->irq,
+                       dm355evm_keys_hardirq, dm355evm_keys_irq,
+                       IRQF_TRIGGER_FALLING,
+                       dev_name(&pdev->dev), keys);
        if (status < 0)
                goto fail1;
 
index 41fda8c67b1ead39b9a317bf18f6c7ac0f8d0556..a6fb7a3dcc46bca0b3770fd89ef2e1fd94e55b84 100644 (file)
@@ -231,7 +231,7 @@ static int __init psif_probe(struct platform_device *pdev)
                goto out_free_io;
        }
 
-       psif->regs = ioremap(regs->start, regs->end - regs->start + 1);
+       psif->regs = ioremap(regs->start, resource_size(regs));
        if (!psif->regs) {
                ret = -ENOMEM;
                dev_dbg(&pdev->dev, "could not map I/O memory\n");
index 72e2712c7e2a6a51ff023d8485d32eb1c941fd1c..07703bcb64c261ed80d63c7dc629f7379ace4a63 100644 (file)
@@ -366,11 +366,11 @@ config TOUCHSCREEN_WM97XX_ATMEL
          be called atmel-wm97xx.
 
 config TOUCHSCREEN_WM97XX_MAINSTONE
-       tristate "WM97xx Mainstone accelerated touch"
+       tristate "WM97xx Mainstone/Palm accelerated touch"
        depends on TOUCHSCREEN_WM97XX && ARCH_PXA
        help
          Say Y here for support for streaming mode with WM97xx touchscreens
-         on Mainstone systems.
+         on Mainstone, Palm Tungsten T5, TX and LifeDrive systems.
 
          If unsure, say N.
 
@@ -406,6 +406,7 @@ config TOUCHSCREEN_USB_COMPOSITE
          - IRTOUCHSYSTEMS/UNITOP
          - IdealTEK URTC1000
          - GoTop Super_Q2/GogoPen/PenPower tablets
+         - JASTEC USB Touch Controller/DigiTech DTR-02U
 
          Have a look at <http://linux.chapter7.ch/touchkit/> for
          a usage description and the required user-space stuff.
@@ -468,6 +469,11 @@ config TOUCHSCREEN_USB_GOTOP
        bool "GoTop Super_Q2/GogoPen/PenPower tablet device support" if EMBEDDED
        depends on TOUCHSCREEN_USB_COMPOSITE
 
+config TOUCHSCREEN_USB_JASTEC
+       default y
+       bool "JASTEC/DigiTech DTR-02U USB touch controller device support" if EMBEDDED
+       depends on TOUCHSCREEN_USB_COMPOSITE
+
 config TOUCHSCREEN_TOUCHIT213
        tristate "Sahara TouchIT-213 touchscreen"
        select SERIO
@@ -492,6 +498,7 @@ config TOUCHSCREEN_TSC2007
 
 config TOUCHSCREEN_W90X900
        tristate "W90P910 touchscreen driver"
+       depends on HAVE_CLK
        help
          Say Y here if you have a W90P910 based touchscreen.
 
index 055969e8be132de9a3954c85384b9801b4bcb667..9c7fce4d74d09b3f6ec1927e87ad659a6fc8a910 100644 (file)
@@ -204,14 +204,14 @@ static int __devinit atmel_tsadcc_probe(struct platform_device *pdev)
                goto err_free_dev;
        }
 
-       if (!request_mem_region(res->start, res->end - res->start + 1,
+       if (!request_mem_region(res->start, resource_size(res),
                                "atmel tsadcc regs")) {
                dev_err(&pdev->dev, "resources is unavailable.\n");
                err = -EBUSY;
                goto err_free_dev;
        }
 
-       tsc_base = ioremap(res->start, res->end - res->start + 1);
+       tsc_base = ioremap(res->start, resource_size(res));
        if (!tsc_base) {
                dev_err(&pdev->dev, "failed to map registers.\n");
                err = -ENOMEM;
@@ -286,7 +286,7 @@ err_free_irq:
 err_unmap_regs:
        iounmap(tsc_base);
 err_release_mem:
-       release_mem_region(res->start, res->end - res->start + 1);
+       release_mem_region(res->start, resource_size(res));
 err_free_dev:
        input_free_device(ts_dev->input);
 err_free_mem:
@@ -305,7 +305,7 @@ static int __devexit atmel_tsadcc_remove(struct platform_device *pdev)
 
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        iounmap(tsc_base);
-       release_mem_region(res->start, res->end - res->start + 1);
+       release_mem_region(res->start, resource_size(res));
 
        clk_disable(ts_dev->clk);
        clk_put(ts_dev->clk);
index 4cc047a5116ec0ce61af2a34aefd645fd91404d3..8fc3b08deb3beb9f75651b698a6a7c3b3269cc46 100644 (file)
 #include <linux/interrupt.h>
 #include <linux/wm97xx.h>
 #include <linux/io.h>
+#include <linux/gpio.h>
+
 #include <mach/regs-ac97.h>
 
-#define VERSION                "0.13"
+#include <asm/mach-types.h>
 
 struct continuous {
        u16 id;    /* codec id */
@@ -62,6 +64,7 @@ static const struct continuous cinfo[] = {
 /* continuous speed index */
 static int sp_idx;
 static u16 last, tries;
+static int irq;
 
 /*
  * Pen sampling frequency (Hz) in continuous mode.
@@ -171,7 +174,7 @@ up:
 
 static int wm97xx_acc_startup(struct wm97xx *wm)
 {
-       int idx = 0;
+       int idx = 0, ret = 0;
 
        /* check we have a codec */
        if (wm->ac97 == NULL)
@@ -191,18 +194,40 @@ static int wm97xx_acc_startup(struct wm97xx *wm)
                 "mainstone accelerated touchscreen driver, %d samples/sec\n",
                 cinfo[sp_idx].speed);
 
+       /* IRQ driven touchscreen is used on Palm hardware */
+       if (machine_is_palmt5() || machine_is_palmtx() || machine_is_palmld()) {
+               pen_int = 1;
+               irq = 27;
+               /* There is some obscure mutant of WM9712 interbred with WM9713
+                * used on Palm HW */
+               wm->variant = WM97xx_WM1613;
+       } else if (machine_is_mainstone() && pen_int)
+               irq = 4;
+
+       if (irq) {
+               ret = gpio_request(irq, "Touchscreen IRQ");
+               if (ret)
+                       goto out;
+
+               ret = gpio_direction_input(irq);
+               if (ret) {
+                       gpio_free(irq);
+                       goto out;
+               }
+
+               wm->pen_irq = gpio_to_irq(irq);
+               set_irq_type(wm->pen_irq, IRQ_TYPE_EDGE_BOTH);
+       } else /* pen irq not supported */
+               pen_int = 0;
+
        /* codec specific irq config */
        if (pen_int) {
                switch (wm->id) {
                case WM9705_ID2:
-                       wm->pen_irq = IRQ_GPIO(4);
-                       set_irq_type(IRQ_GPIO(4), IRQ_TYPE_EDGE_BOTH);
                        break;
                case WM9712_ID2:
                case WM9713_ID2:
-                       /* enable pen down interrupt */
                        /* use PEN_DOWN GPIO 13 to assert IRQ on GPIO line 2 */
-                       wm->pen_irq = MAINSTONE_AC97_IRQ;
                        wm97xx_config_gpio(wm, WM97XX_GPIO_13, WM97XX_GPIO_IN,
                                           WM97XX_GPIO_POL_HIGH,
                                           WM97XX_GPIO_STICKY,
@@ -220,23 +245,17 @@ static int wm97xx_acc_startup(struct wm97xx *wm)
                }
        }
 
-       return 0;
+out:
+       return ret;
 }
 
 static void wm97xx_acc_shutdown(struct wm97xx *wm)
 {
        /* codec specific deconfig */
        if (pen_int) {
-               switch (wm->id & 0xffff) {
-               case WM9705_ID2:
-                       wm->pen_irq = 0;
-                       break;
-               case WM9712_ID2:
-               case WM9713_ID2:
-                       /* disable interrupt */
-                       wm->pen_irq = 0;
-                       break;
-               }
+               if (irq)
+                       gpio_free(irq);
+               wm->pen_irq = 0;
        }
 }
 
index 6954f55001080d29b337a37c9398b6c8f867ec1a..e85483578bd4f2207e82c257430fc63a2d6d02d1 100644 (file)
@@ -128,9 +128,10 @@ static inline unsigned int ucb1400_ts_read_yres(struct ucb1400_ts *ucb)
        return ucb1400_adc_read(ucb->ac97, 0, adcsync);
 }
 
-static inline int ucb1400_ts_pen_down(struct snd_ac97 *ac97)
+static inline int ucb1400_ts_pen_up(struct snd_ac97 *ac97)
 {
        unsigned short val = ucb1400_reg_read(ac97, UCB_TS_CR);
+
        return val & (UCB_TS_CR_TSPX_LOW | UCB_TS_CR_TSMX_LOW);
 }
 
@@ -209,7 +210,7 @@ static int ucb1400_ts_thread(void *_ucb)
 
                msleep(10);
 
-               if (ucb1400_ts_pen_down(ucb->ac97)) {
+               if (ucb1400_ts_pen_up(ucb->ac97)) {
                        ucb1400_ts_irq_enable(ucb->ac97);
 
                        /*
index fb7cb9bdfbd5c4971cedeb064b8839ae3d09365a..c07be07a69bbafdd0559432c807e73e1ed548bc7 100644 (file)
@@ -13,6 +13,7 @@
  *  - IdealTEK URTC1000
  *  - General Touch
  *  - GoTop Super_Q2/GogoPen/PenPower tablets
+ *  - JASTEC USB touch controller/DigiTech DTR-02U
  *
  * Copyright (C) 2004-2007 by Daniel Ritz <daniel.ritz@gmx.ch>
  * Copyright (C) by Todd E. Johnson (mtouchusb.c)
@@ -118,6 +119,7 @@ enum {
        DEVTYPE_IDEALTEK,
        DEVTYPE_GENERAL_TOUCH,
        DEVTYPE_GOTOP,
+       DEVTYPE_JASTEC,
 };
 
 #define USB_DEVICE_HID_CLASS(vend, prod) \
@@ -191,6 +193,10 @@ static struct usb_device_id usbtouch_devices[] = {
        {USB_DEVICE(0x08f2, 0x00f4), .driver_info = DEVTYPE_GOTOP},
 #endif
 
+#ifdef CONFIG_TOUCHSCREEN_USB_JASTEC
+       {USB_DEVICE(0x0f92, 0x0001), .driver_info = DEVTYPE_JASTEC},
+#endif
+
        {}
 };
 
@@ -559,6 +565,21 @@ static int gotop_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
        dev->x = ((pkt[1] & 0x38) << 4) | pkt[2];
        dev->y = ((pkt[1] & 0x07) << 7) | pkt[3];
        dev->touch = pkt[0] & 0x01;
+
+       return 1;
+}
+#endif
+
+/*****************************************************************************
+ * JASTEC Part
+ */
+#ifdef CONFIG_TOUCHSCREEN_USB_JASTEC
+static int jastec_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
+{
+       dev->x = ((pkt[0] & 0x3f) << 6) | (pkt[2] & 0x3f);
+       dev->y = ((pkt[1] & 0x3f) << 6) | (pkt[3] & 0x3f);
+       dev->touch = (pkt[0] & 0x40) >> 6;
+
        return 1;
 }
 #endif
@@ -702,6 +723,17 @@ static struct usbtouch_device_info usbtouch_dev_info[] = {
                .read_data      = gotop_read_data,
        },
 #endif
+
+#ifdef CONFIG_TOUCHSCREEN_USB_JASTEC
+       [DEVTYPE_JASTEC] = {
+               .min_xc         = 0x0,
+               .max_xc         = 0x0fff,
+               .min_yc         = 0x0,
+               .max_yc         = 0x0fff,
+               .rept_size      = 4,
+               .read_data      = jastec_read_data,
+       },
+#endif
 };
 
 
index 6071f5882572e2659ec77eae1a7f4d62554cd2fc..dc4c9d6b67c782f4fafe9725980a48fbf57a1555 100644 (file)
@@ -13,6 +13,7 @@
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
+#include <linux/clk.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
 
@@ -47,8 +48,8 @@ enum ts_state {
 struct w90p910_ts {
        struct input_dev *input;
        struct timer_list timer;
+       struct clk *clk;
        int irq_num;
-       void __iomem *clocken;
        void __iomem *ts_reg;
        spinlock_t lock;
        enum ts_state state;
@@ -166,8 +167,7 @@ static int w90p910_open(struct input_dev *dev)
        unsigned long val;
 
        /* enable the ADC clock */
-       val = __raw_readl(w90p910_ts->clocken);
-       __raw_writel(val | ADC_CLK_EN, w90p910_ts->clocken);
+       clk_enable(w90p910_ts->clk);
 
        __raw_writel(ADC_RST1, w90p910_ts->ts_reg);
        msleep(1);
@@ -211,8 +211,7 @@ static void w90p910_close(struct input_dev *dev)
        del_timer_sync(&w90p910_ts->timer);
 
        /* stop the ADC clock */
-       val = __raw_readl(w90p910_ts->clocken);
-       __raw_writel(val & ~ADC_CLK_EN, w90p910_ts->clocken);
+       clk_disable(w90p910_ts->clk);
 }
 
 static int __devinit w90x900ts_probe(struct platform_device *pdev)
@@ -241,26 +240,24 @@ static int __devinit w90x900ts_probe(struct platform_device *pdev)
                goto fail1;
        }
 
-       if (!request_mem_region(res->start, res->end - res->start + 1,
+       if (!request_mem_region(res->start, resource_size(res),
                                pdev->name)) {
                err = -EBUSY;
                goto fail1;
        }
 
-       w90p910_ts->ts_reg = ioremap(res->start, res->end - res->start + 1);
+       w90p910_ts->ts_reg = ioremap(res->start, resource_size(res));
        if (!w90p910_ts->ts_reg) {
                err = -ENOMEM;
                goto fail2;
        }
 
-       res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-       if (!res) {
-               err = -ENXIO;
+       w90p910_ts->clk = clk_get(&pdev->dev, NULL);
+       if (IS_ERR(w90p910_ts->clk)) {
+               err = PTR_ERR(w90p910_ts->clk);
                goto fail3;
        }
 
-       w90p910_ts->clocken = (void __iomem *)res->start;
-
        input_dev->name = "W90P910 TouchScreen";
        input_dev->phys = "w90p910ts/event0";
        input_dev->id.bustype = BUS_HOST;
@@ -283,20 +280,21 @@ static int __devinit w90x900ts_probe(struct platform_device *pdev)
        if (request_irq(w90p910_ts->irq_num, w90p910_ts_interrupt,
                        IRQF_DISABLED, "w90p910ts", w90p910_ts)) {
                err = -EBUSY;
-               goto fail3;
+               goto fail4;
        }
 
        err = input_register_device(w90p910_ts->input);
        if (err)
-               goto fail4;
+               goto fail5;
 
        platform_set_drvdata(pdev, w90p910_ts);
 
        return 0;
 
-fail4: free_irq(w90p910_ts->irq_num, w90p910_ts);
+fail5: free_irq(w90p910_ts->irq_num, w90p910_ts);
+fail4: clk_put(w90p910_ts->clk);
 fail3: iounmap(w90p910_ts->ts_reg);
-fail2: release_mem_region(res->start, res->end - res->start + 1);
+fail2: release_mem_region(res->start, resource_size(res));
 fail1: input_free_device(input_dev);
        kfree(w90p910_ts);
        return err;
@@ -311,8 +309,10 @@ static int __devexit w90x900ts_remove(struct platform_device *pdev)
        del_timer_sync(&w90p910_ts->timer);
        iounmap(w90p910_ts->ts_reg);
 
+       clk_put(w90p910_ts->clk);
+
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-       release_mem_region(res->start, res->end - res->start + 1);
+       release_mem_region(res->start, resource_size(res));
 
        input_unregister_device(w90p910_ts->input);
        kfree(w90p910_ts);
index 2957d48e0045fa05d68bb38aafe6ec8c9d3462d8..252eb11fe9db141118aef9b086c5590eb588d063 100644 (file)
@@ -204,7 +204,7 @@ void wm97xx_set_gpio(struct wm97xx *wm, u32 gpio,
        else
                reg &= ~gpio;
 
-       if (wm->id == WM9712_ID2)
+       if (wm->id == WM9712_ID2 && wm->variant != WM97xx_WM1613)
                wm97xx_reg_write(wm, AC97_GPIO_STATUS, reg << 1);
        else
                wm97xx_reg_write(wm, AC97_GPIO_STATUS, reg);
@@ -307,7 +307,7 @@ static void wm97xx_pen_irq_worker(struct work_struct *work)
                                         WM97XX_GPIO_13);
                }
 
-               if (wm->id == WM9712_ID2)
+               if (wm->id == WM9712_ID2 && wm->variant != WM97xx_WM1613)
                        wm97xx_reg_write(wm, AC97_GPIO_STATUS, (status &
                                                ~WM97XX_GPIO_13) << 1);
                else
@@ -582,6 +582,8 @@ static int wm97xx_probe(struct device *dev)
 
        wm->id = wm97xx_reg_read(wm, AC97_VENDOR_ID2);
 
+       wm->variant = WM97xx_GENERIC;
+
        dev_info(wm->dev, "detected a wm97%02x codec\n", wm->id & 0xff);
 
        switch (wm->id & 0xff) {
index 6f69968eab244f63ec956c2ce7cb8cdb6ca9bacf..0c9878123d5fa7096efd679c81058ed53662ad46 100644 (file)
 #include <linux/input.h>       /* Input device layer */
 #include <linux/platform_device.h>
 
+/*
+ * WM97xx variants
+ */
+#define        WM97xx_GENERIC                  0x0000
+#define        WM97xx_WM1613                   0x1613
+
 /*
  * WM97xx AC97 Touchscreen registers
  */
@@ -283,6 +289,7 @@ struct wm97xx {
        unsigned pen_is_down:1;         /* Pen is down */
        unsigned aux_waiting:1;         /* aux measurement waiting */
        unsigned pen_probably_down:1;   /* used in polling mode */
+       u16 variant;                    /* WM97xx chip variant */
        u16 suspend_mode;               /* PRP in suspend mode */
 };