| /* |
| * wm97xx-core.c -- Touch screen driver core for Wolfson WM9705, WM9712 |
| * and WM9713 AC97 Codecs. |
| * |
| * Copyright 2003, 2004, 2005, 2006, 2007, 2008 Wolfson Microelectronics PLC. |
| * Author: Liam Girdwood |
| * liam.girdwood@wolfsonmicro.com or linux@wolfsonmicro.com |
| * Parts Copyright : Ian Molton <spyro@f2s.com> |
| * Andrew Zabolotny <zap@homelink.ru> |
| * Russell King <rmk@arm.linux.org.uk> |
| * |
| * 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. |
| * |
| * Notes: |
| * |
| * Features: |
| * - supports WM9705, WM9712, WM9713 |
| * - polling mode |
| * - continuous mode (arch-dependent) |
| * - adjustable rpu/dpp settings |
| * - adjustable pressure current |
| * - adjustable sample settle delay |
| * - 4 and 5 wire touchscreens (5 wire is WM9712 only) |
| * - pen down detection |
| * - battery monitor |
| * - sample AUX adcs |
| * - power management |
| * - codec GPIO |
| * - codec event notification |
| * Todo |
| * - Support for async sampling control for noisy LCDs. |
| * |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/moduleparam.h> |
| #include <linux/kernel.h> |
| #include <linux/init.h> |
| #include <linux/delay.h> |
| #include <linux/string.h> |
| #include <linux/proc_fs.h> |
| #include <linux/pm.h> |
| #include <linux/interrupt.h> |
| #include <linux/bitops.h> |
| #include <linux/workqueue.h> |
| #include <linux/wm97xx.h> |
| #include <linux/uaccess.h> |
| #include <linux/io.h> |
| |
| #define TS_NAME "wm97xx" |
| #define WM_CORE_VERSION "1.00" |
| #define DEFAULT_PRESSURE 0xb0c0 |
| |
| |
| /* |
| * Touchscreen absolute values |
| * |
| * These parameters are used to help the input layer discard out of |
| * range readings and reduce jitter etc. |
| * |
| * o min, max:- indicate the min and max values your touch screen returns |
| * o fuzz:- use a higher number to reduce jitter |
| * |
| * The default values correspond to Mainstone II in QVGA mode |
| * |
| * Please read |
| * Documentation/input/input-programming.txt for more details. |
| */ |
| |
| static int abs_x[3] = {350, 3900, 5}; |
| module_param_array(abs_x, int, NULL, 0); |
| MODULE_PARM_DESC(abs_x, "Touchscreen absolute X min, max, fuzz"); |
| |
| static int abs_y[3] = {320, 3750, 40}; |
| module_param_array(abs_y, int, NULL, 0); |
| MODULE_PARM_DESC(abs_y, "Touchscreen absolute Y min, max, fuzz"); |
| |
| static int abs_p[3] = {0, 150, 4}; |
| module_param_array(abs_p, int, NULL, 0); |
| MODULE_PARM_DESC(abs_p, "Touchscreen absolute Pressure min, max, fuzz"); |
| |
| /* |
| * wm97xx IO access, all IO locking done by AC97 layer |
| */ |
| int wm97xx_reg_read(struct wm97xx *wm, u16 reg) |
| { |
| if (wm->ac97) |
| return wm->ac97->bus->ops->read(wm->ac97, reg); |
| else |
| return -1; |
| } |
| EXPORT_SYMBOL_GPL(wm97xx_reg_read); |
| |
| void wm97xx_reg_write(struct wm97xx *wm, u16 reg, u16 val) |
| { |
| /* cache digitiser registers */ |
| if (reg >= AC97_WM9713_DIG1 && reg <= AC97_WM9713_DIG3) |
| wm->dig[(reg - AC97_WM9713_DIG1) >> 1] = val; |
| |
| /* cache gpio regs */ |
| if (reg >= AC97_GPIO_CFG && reg <= AC97_MISC_AFE) |
| wm->gpio[(reg - AC97_GPIO_CFG) >> 1] = val; |
| |
| /* wm9713 irq reg */ |
| if (reg == 0x5a) |
| wm->misc = val; |
| |
| if (wm->ac97) |
| wm->ac97->bus->ops->write(wm->ac97, reg, val); |
| } |
| EXPORT_SYMBOL_GPL(wm97xx_reg_write); |
| |
| /** |
| * wm97xx_read_aux_adc - Read the aux adc. |
| * @wm: wm97xx device. |
| * @adcsel: codec ADC to be read |
| * |
| * Reads the selected AUX ADC. |
| */ |
| |
| int wm97xx_read_aux_adc(struct wm97xx *wm, u16 adcsel) |
| { |
| int power_adc = 0, auxval; |
| u16 power = 0; |
| |
| /* get codec */ |
| mutex_lock(&wm->codec_mutex); |
| |
| /* When the touchscreen is not in use, we may have to power up |
| * the AUX ADC before we can use sample the AUX inputs-> |
| */ |
| if (wm->id == WM9713_ID2 && |
| (power = wm97xx_reg_read(wm, AC97_EXTENDED_MID)) & 0x8000) { |
| power_adc = 1; |
| wm97xx_reg_write(wm, AC97_EXTENDED_MID, power & 0x7fff); |
| } |
| |
| /* Prepare the codec for AUX reading */ |
| wm->codec->aux_prepare(wm); |
| |
| /* Turn polling mode on to read AUX ADC */ |
| wm->pen_probably_down = 1; |
| wm->codec->poll_sample(wm, adcsel, &auxval); |
| |
| if (power_adc) |
| wm97xx_reg_write(wm, AC97_EXTENDED_MID, power | 0x8000); |
| |
| wm->codec->dig_restore(wm); |
| |
| wm->pen_probably_down = 0; |
| |
| mutex_unlock(&wm->codec_mutex); |
| return auxval & 0xfff; |
| } |
| EXPORT_SYMBOL_GPL(wm97xx_read_aux_adc); |
| |
| /** |
| * wm97xx_get_gpio - Get the status of a codec GPIO. |
| * @wm: wm97xx device. |
| * @gpio: gpio |
| * |
| * Get the status of a codec GPIO pin |
| */ |
| |
| enum wm97xx_gpio_status wm97xx_get_gpio(struct wm97xx *wm, u32 gpio) |
| { |
| u16 status; |
| enum wm97xx_gpio_status ret; |
| |
| mutex_lock(&wm->codec_mutex); |
| status = wm97xx_reg_read(wm, AC97_GPIO_STATUS); |
| |
| if (status & gpio) |
| ret = WM97XX_GPIO_HIGH; |
| else |
| ret = WM97XX_GPIO_LOW; |
| |
| mutex_unlock(&wm->codec_mutex); |
| return ret; |
| } |
| EXPORT_SYMBOL_GPL(wm97xx_get_gpio); |
| |
| /** |
| * wm97xx_set_gpio - Set the status of a codec GPIO. |
| * @wm: wm97xx device. |
| * @gpio: gpio |
| * |
| * |
| * Set the status of a codec GPIO pin |
| */ |
| |
| void wm97xx_set_gpio(struct wm97xx *wm, u32 gpio, |
| enum wm97xx_gpio_status status) |
| { |
| u16 reg; |
| |
| mutex_lock(&wm->codec_mutex); |
| reg = wm97xx_reg_read(wm, AC97_GPIO_STATUS); |
| |
| if (status & WM97XX_GPIO_HIGH) |
| reg |= gpio; |
| else |
| reg &= ~gpio; |
| |
| if (wm->id == WM9712_ID2) |
| wm97xx_reg_write(wm, AC97_GPIO_STATUS, reg << 1); |
| else |
| wm97xx_reg_write(wm, AC97_GPIO_STATUS, reg); |
| mutex_unlock(&wm->codec_mutex); |
| } |
| EXPORT_SYMBOL_GPL(wm97xx_set_gpio); |
| |
| /* |
| * Codec GPIO pin configuration, this sets pin direction, polarity, |
| * stickyness and wake up. |
| */ |
| void wm97xx_config_gpio(struct wm97xx *wm, u32 gpio, enum wm97xx_gpio_dir dir, |
| enum wm97xx_gpio_pol pol, enum wm97xx_gpio_sticky sticky, |
| enum wm97xx_gpio_wake wake) |
| { |
| u16 reg; |
| |
| mutex_lock(&wm->codec_mutex); |
| reg = wm97xx_reg_read(wm, AC97_GPIO_POLARITY); |
| |
| if (pol == WM97XX_GPIO_POL_HIGH) |
| reg |= gpio; |
| else |
| reg &= ~gpio; |
| |
| wm97xx_reg_write(wm, AC97_GPIO_POLARITY, reg); |
| reg = wm97xx_reg_read(wm, AC97_GPIO_STICKY); |
| |
| if (sticky == WM97XX_GPIO_STICKY) |
| reg |= gpio; |
| else |
| reg &= ~gpio; |
| |
| wm97xx_reg_write(wm, AC97_GPIO_STICKY, reg); |
| reg = wm97xx_reg_read(wm, AC97_GPIO_WAKEUP); |
| |
| if (wake == WM97XX_GPIO_WAKE) |
| reg |= gpio; |
| else |
| reg &= ~gpio; |
| |
| wm97xx_reg_write(wm, AC97_GPIO_WAKEUP, reg); |
| reg = wm97xx_reg_read(wm, AC97_GPIO_CFG); |
| |
| if (dir == WM97XX_GPIO_IN) |
| reg |= gpio; |
| else |
| reg &= ~gpio; |
| |
| wm97xx_reg_write(wm, AC97_GPIO_CFG, reg); |
| mutex_unlock(&wm->codec_mutex); |
| } |
| EXPORT_SYMBOL_GPL(wm97xx_config_gpio); |
| |
| /* |
| * Configure the WM97XX_PRP value to use while system is suspended. |
| * If a value other than 0 is set then WM97xx pen detection will be |
| * left enabled in the configured mode while the system is in suspend, |
| * the device has users and suspend has not been disabled via the |
| * wakeup sysfs entries. |
| * |
| * @wm: WM97xx device to configure |
| * @mode: WM97XX_PRP value to configure while suspended |
| */ |
| void wm97xx_set_suspend_mode(struct wm97xx *wm, u16 mode) |
| { |
| wm->suspend_mode = mode; |
| device_init_wakeup(&wm->input_dev->dev, mode != 0); |
| } |
| EXPORT_SYMBOL_GPL(wm97xx_set_suspend_mode); |
| |
| /* |
| * Handle a pen down interrupt. |
| */ |
| static void wm97xx_pen_irq_worker(struct work_struct *work) |
| { |
| struct wm97xx *wm = container_of(work, struct wm97xx, pen_event_work); |
| int pen_was_down = wm->pen_is_down; |
| |
| /* do we need to enable the touch panel reader */ |
| if (wm->id == WM9705_ID2) { |
| if (wm97xx_reg_read(wm, AC97_WM97XX_DIGITISER_RD) & |
| WM97XX_PEN_DOWN) |
| wm->pen_is_down = 1; |
| else |
| wm->pen_is_down = 0; |
| } else { |
| u16 status, pol; |
| mutex_lock(&wm->codec_mutex); |
| status = wm97xx_reg_read(wm, AC97_GPIO_STATUS); |
| pol = wm97xx_reg_read(wm, AC97_GPIO_POLARITY); |
| |
| if (WM97XX_GPIO_13 & pol & status) { |
| wm->pen_is_down = 1; |
| wm97xx_reg_write(wm, AC97_GPIO_POLARITY, pol & |
| ~WM97XX_GPIO_13); |
| } else { |
| wm->pen_is_down = 0; |
| wm97xx_reg_write(wm, AC97_GPIO_POLARITY, pol | |
| WM97XX_GPIO_13); |
| } |
| |
| if (wm->id == WM9712_ID2) |
| wm97xx_reg_write(wm, AC97_GPIO_STATUS, (status & |
| ~WM97XX_GPIO_13) << 1); |
| else |
| wm97xx_reg_write(wm, AC97_GPIO_STATUS, status & |
| ~WM97XX_GPIO_13); |
| mutex_unlock(&wm->codec_mutex); |
| } |
| |
| /* If the system is not using continuous mode or it provides a |
| * pen down operation then we need to schedule polls while the |
| * pen is down. Otherwise the machine driver is responsible |
| * for scheduling reads. |
| */ |
| if (!wm->mach_ops->acc_enabled || wm->mach_ops->acc_pen_down) { |
| if (wm->pen_is_down && !pen_was_down) { |
| /* Data is not availiable immediately on pen down */ |
| queue_delayed_work(wm->ts_workq, &wm->ts_reader, 1); |
| } |
| |
| /* Let ts_reader report the pen up for debounce. */ |
| if (!wm->pen_is_down && pen_was_down) |
| wm->pen_is_down = 1; |
| } |
| |
| if (!wm->pen_is_down && wm->mach_ops->acc_enabled) |
| wm->mach_ops->acc_pen_up(wm); |
| |
| wm->mach_ops->irq_enable(wm, 1); |
| } |
| |
| /* |
| * Codec PENDOWN irq handler |
| * |
| * We have to disable the codec interrupt in the handler because it |
| * can take upto 1ms to clear the interrupt source. We schedule a task |
| * in a work queue to do the actual interaction with the chip. The |
| * interrupt is then enabled again in the slow handler when the source |
| * has been cleared. |
| */ |
| static irqreturn_t wm97xx_pen_interrupt(int irq, void *dev_id) |
| { |
| struct wm97xx *wm = dev_id; |
| |
| if (!work_pending(&wm->pen_event_work)) { |
| wm->mach_ops->irq_enable(wm, 0); |
| queue_work(wm->ts_workq, &wm->pen_event_work); |
| } |
| |
| return IRQ_HANDLED; |
| } |
| |
| /* |
| * initialise pen IRQ handler and workqueue |
| */ |
| static int wm97xx_init_pen_irq(struct wm97xx *wm) |
| { |
| u16 reg; |
| |
| /* If an interrupt is supplied an IRQ enable operation must also be |
| * provided. */ |
| BUG_ON(!wm->mach_ops->irq_enable); |
| |
| if (request_irq(wm->pen_irq, wm97xx_pen_interrupt, |
| IRQF_SHARED | IRQF_SAMPLE_RANDOM, |
| "wm97xx-pen", wm)) { |
| dev_err(wm->dev, |
| "Failed to register pen down interrupt, polling"); |
| wm->pen_irq = 0; |
| return -EINVAL; |
| } |
| |
| /* Configure GPIO as interrupt source on WM971x */ |
| if (wm->id != WM9705_ID2) { |
| BUG_ON(!wm->mach_ops->irq_gpio); |
| reg = wm97xx_reg_read(wm, AC97_MISC_AFE); |
| wm97xx_reg_write(wm, AC97_MISC_AFE, |
| reg & ~(wm->mach_ops->irq_gpio)); |
| reg = wm97xx_reg_read(wm, 0x5a); |
| wm97xx_reg_write(wm, 0x5a, reg & ~0x0001); |
| } |
| |
| return 0; |
| } |
| |
| static int wm97xx_read_samples(struct wm97xx *wm) |
| { |
| struct wm97xx_data data; |
| int rc; |
| |
| mutex_lock(&wm->codec_mutex); |
| |
| if (wm->mach_ops && wm->mach_ops->acc_enabled) |
| rc = wm->mach_ops->acc_pen_down(wm); |
| else |
| rc = wm->codec->poll_touch(wm, &data); |
| |
| if (rc & RC_PENUP) { |
| if (wm->pen_is_down) { |
| wm->pen_is_down = 0; |
| dev_dbg(wm->dev, "pen up\n"); |
| input_report_abs(wm->input_dev, ABS_PRESSURE, 0); |
| input_sync(wm->input_dev); |
| } else if (!(rc & RC_AGAIN)) { |
| /* We need high frequency updates only while |
| * pen is down, the user never will be able to |
| * touch screen faster than a few times per |
| * second... On the other hand, when the user |
| * is actively working with the touchscreen we |
| * don't want to lose the quick response. So we |
| * will slowly increase sleep time after the |
| * pen is up and quicky restore it to ~one task |
| * switch when pen is down again. |
| */ |
| if (wm->ts_reader_interval < HZ / 10) |
| wm->ts_reader_interval++; |
| } |
| |
| } else if (rc & RC_VALID) { |
| dev_dbg(wm->dev, |
| "pen down: x=%x:%d, y=%x:%d, pressure=%x:%d\n", |
| data.x >> 12, data.x & 0xfff, data.y >> 12, |
| data.y & 0xfff, data.p >> 12, data.p & 0xfff); |
| input_report_abs(wm->input_dev, ABS_X, data.x & 0xfff); |
| input_report_abs(wm->input_dev, ABS_Y, data.y & 0xfff); |
| input_report_abs(wm->input_dev, ABS_PRESSURE, data.p & 0xfff); |
| input_sync(wm->input_dev); |
| wm->pen_is_down = 1; |
| wm->ts_reader_interval = wm->ts_reader_min_interval; |
| } else if (rc & RC_PENDOWN) { |
| dev_dbg(wm->dev, "pen down\n"); |
| wm->pen_is_down = 1; |
| wm->ts_reader_interval = wm->ts_reader_min_interval; |
| } |
| |
| mutex_unlock(&wm->codec_mutex); |
| return rc; |
| } |
| |
| /* |
| * The touchscreen sample reader. |
| */ |
| static void wm97xx_ts_reader(struct work_struct *work) |
| { |
| int rc; |
| struct wm97xx *wm = container_of(work, struct wm97xx, ts_reader.work); |
| |
| BUG_ON(!wm->codec); |
| |
| do { |
| rc = wm97xx_read_samples(wm); |
| } while (rc & RC_AGAIN); |
| |
| if (wm->pen_is_down || !wm->pen_irq) |
| queue_delayed_work(wm->ts_workq, &wm->ts_reader, |
| wm->ts_reader_interval); |
| } |
| |
| /** |
| * wm97xx_ts_input_open - Open the touch screen input device. |
| * @idev: Input device to be opened. |
| * |
| * Called by the input sub system to open a wm97xx touchscreen device. |
| * Starts the touchscreen thread and touch digitiser. |
| */ |
| static int wm97xx_ts_input_open(struct input_dev *idev) |
| { |
| struct wm97xx *wm = input_get_drvdata(idev); |
| |
| wm->ts_workq = create_singlethread_workqueue("kwm97xx"); |
| if (wm->ts_workq == NULL) { |
| dev_err(wm->dev, |
| "Failed to create workqueue\n"); |
| return -EINVAL; |
| } |
| |
| /* start digitiser */ |
| if (wm->mach_ops && wm->mach_ops->acc_enabled) |
| wm->codec->acc_enable(wm, 1); |
| wm->codec->dig_enable(wm, 1); |
| |
| INIT_DELAYED_WORK(&wm->ts_reader, wm97xx_ts_reader); |
| INIT_WORK(&wm->pen_event_work, wm97xx_pen_irq_worker); |
| |
| wm->ts_reader_min_interval = HZ >= 100 ? HZ / 100 : 1; |
| if (wm->ts_reader_min_interval < 1) |
| wm->ts_reader_min_interval = 1; |
| wm->ts_reader_interval = wm->ts_reader_min_interval; |
| |
| wm->pen_is_down = 0; |
| if (wm->pen_irq) |
| wm97xx_init_pen_irq(wm); |
| else |
| dev_err(wm->dev, "No IRQ specified\n"); |
| |
| /* If we either don't have an interrupt for pen down events or |
| * failed to acquire it then we need to poll. |
| */ |
| if (wm->pen_irq == 0) |
| queue_delayed_work(wm->ts_workq, &wm->ts_reader, |
| wm->ts_reader_interval); |
| |
| return 0; |
| } |
| |
| /** |
| * wm97xx_ts_input_close - Close the touch screen input device. |
| * @idev: Input device to be closed. |
| * |
| * Called by the input sub system to close a wm97xx touchscreen |
| * device. Kills the touchscreen thread and stops the touch |
| * digitiser. |
| */ |
| |
| static void wm97xx_ts_input_close(struct input_dev *idev) |
| { |
| struct wm97xx *wm = input_get_drvdata(idev); |
| u16 reg; |
| |
| if (wm->pen_irq) { |
| /* Return the interrupt to GPIO usage (disabling it) */ |
| if (wm->id != WM9705_ID2) { |
| BUG_ON(!wm->mach_ops->irq_gpio); |
| reg = wm97xx_reg_read(wm, AC97_MISC_AFE); |
| wm97xx_reg_write(wm, AC97_MISC_AFE, |
| reg | wm->mach_ops->irq_gpio); |
| } |
| |
| free_irq(wm->pen_irq, wm); |
| } |
| |
| wm->pen_is_down = 0; |
| |
| /* Balance out interrupt disables/enables */ |
| if (cancel_work_sync(&wm->pen_event_work)) |
| wm->mach_ops->irq_enable(wm, 1); |
| |
| /* ts_reader rearms itself so we need to explicitly stop it |
| * before we destroy the workqueue. |
| */ |
| cancel_delayed_work_sync(&wm->ts_reader); |
| |
| destroy_workqueue(wm->ts_workq); |
| |
| /* stop digitiser */ |
| wm->codec->dig_enable(wm, 0); |
| if (wm->mach_ops && wm->mach_ops->acc_enabled) |
| wm->codec->acc_enable(wm, 0); |
| } |
| |
| static int wm97xx_probe(struct device *dev) |
| { |
| struct wm97xx *wm; |
| int ret = 0, id = 0; |
| |
| wm = kzalloc(sizeof(struct wm97xx), GFP_KERNEL); |
| if (!wm) |
| return -ENOMEM; |
| mutex_init(&wm->codec_mutex); |
| |
| wm->dev = dev; |
| dev->driver_data = wm; |
| wm->ac97 = to_ac97_t(dev); |
| |
| /* check that we have a supported codec */ |
| id = wm97xx_reg_read(wm, AC97_VENDOR_ID1); |
| if (id != WM97XX_ID1) { |
| dev_err(dev, "Device with vendor %04x is not a wm97xx\n", id); |
| ret = -ENODEV; |
| goto alloc_err; |
| } |
| |
| wm->id = wm97xx_reg_read(wm, AC97_VENDOR_ID2); |
| |
| dev_info(wm->dev, "detected a wm97%02x codec\n", wm->id & 0xff); |
| |
| switch (wm->id & 0xff) { |
| #ifdef CONFIG_TOUCHSCREEN_WM9705 |
| case 0x05: |
| wm->codec = &wm9705_codec; |
| break; |
| #endif |
| #ifdef CONFIG_TOUCHSCREEN_WM9712 |
| case 0x12: |
| wm->codec = &wm9712_codec; |
| break; |
| #endif |
| #ifdef CONFIG_TOUCHSCREEN_WM9713 |
| case 0x13: |
| wm->codec = &wm9713_codec; |
| break; |
| #endif |
| default: |
| dev_err(wm->dev, "Support for wm97%02x not compiled in.\n", |
| wm->id & 0xff); |
| ret = -ENODEV; |
| goto alloc_err; |
| } |
| |
| /* set up physical characteristics */ |
| wm->codec->phy_init(wm); |
| |
| /* load gpio cache */ |
| wm->gpio[0] = wm97xx_reg_read(wm, AC97_GPIO_CFG); |
| wm->gpio[1] = wm97xx_reg_read(wm, AC97_GPIO_POLARITY); |
| wm->gpio[2] = wm97xx_reg_read(wm, AC97_GPIO_STICKY); |
| wm->gpio[3] = wm97xx_reg_read(wm, AC97_GPIO_WAKEUP); |
| wm->gpio[4] = wm97xx_reg_read(wm, AC97_GPIO_STATUS); |
| wm->gpio[5] = wm97xx_reg_read(wm, AC97_MISC_AFE); |
| |
| wm->input_dev = input_allocate_device(); |
| if (wm->input_dev == NULL) { |
| ret = -ENOMEM; |
| goto alloc_err; |
| } |
| |
| /* set up touch configuration */ |
| wm->input_dev->name = "wm97xx touchscreen"; |
| wm->input_dev->phys = "wm97xx"; |
| wm->input_dev->open = wm97xx_ts_input_open; |
| wm->input_dev->close = wm97xx_ts_input_close; |
| set_bit(EV_ABS, wm->input_dev->evbit); |
| set_bit(ABS_X, wm->input_dev->absbit); |
| set_bit(ABS_Y, wm->input_dev->absbit); |
| set_bit(ABS_PRESSURE, wm->input_dev->absbit); |
| input_set_abs_params(wm->input_dev, ABS_X, abs_x[0], abs_x[1], |
| abs_x[2], 0); |
| input_set_abs_params(wm->input_dev, ABS_Y, abs_y[0], abs_y[1], |
| abs_y[2], 0); |
| input_set_abs_params(wm->input_dev, ABS_PRESSURE, abs_p[0], abs_p[1], |
| abs_p[2], 0); |
| input_set_drvdata(wm->input_dev, wm); |
| wm->input_dev->dev.parent = dev; |
| ret = input_register_device(wm->input_dev); |
| if (ret < 0) |
| goto dev_alloc_err; |
| |
| /* register our battery device */ |
| wm->battery_dev = platform_device_alloc("wm97xx-battery", -1); |
| if (!wm->battery_dev) { |
| ret = -ENOMEM; |
| goto batt_err; |
| } |
| platform_set_drvdata(wm->battery_dev, wm); |
| wm->battery_dev->dev.parent = dev; |
| ret = platform_device_add(wm->battery_dev); |
| if (ret < 0) |
| goto batt_reg_err; |
| |
| /* register our extended touch device (for machine specific |
| * extensions) */ |
| wm->touch_dev = platform_device_alloc("wm97xx-touch", -1); |
| if (!wm->touch_dev) { |
| ret = -ENOMEM; |
| goto touch_err; |
| } |
| platform_set_drvdata(wm->touch_dev, wm); |
| wm->touch_dev->dev.parent = dev; |
| ret = platform_device_add(wm->touch_dev); |
| if (ret < 0) |
| goto touch_reg_err; |
| |
| return ret; |
| |
| touch_reg_err: |
| platform_device_put(wm->touch_dev); |
| touch_err: |
| platform_device_unregister(wm->battery_dev); |
| wm->battery_dev = NULL; |
| batt_reg_err: |
| platform_device_put(wm->battery_dev); |
| batt_err: |
| input_unregister_device(wm->input_dev); |
| wm->input_dev = NULL; |
| dev_alloc_err: |
| input_free_device(wm->input_dev); |
| alloc_err: |
| kfree(wm); |
| |
| return ret; |
| } |
| |
| static int wm97xx_remove(struct device *dev) |
| { |
| struct wm97xx *wm = dev_get_drvdata(dev); |
| |
| platform_device_unregister(wm->battery_dev); |
| platform_device_unregister(wm->touch_dev); |
| input_unregister_device(wm->input_dev); |
| kfree(wm); |
| |
| return 0; |
| } |
| |
| #ifdef CONFIG_PM |
| static int wm97xx_suspend(struct device *dev, pm_message_t state) |
| { |
| struct wm97xx *wm = dev_get_drvdata(dev); |
| u16 reg; |
| int suspend_mode; |
| |
| if (device_may_wakeup(&wm->input_dev->dev)) |
| suspend_mode = wm->suspend_mode; |
| else |
| suspend_mode = 0; |
| |
| if (wm->input_dev->users) |
| cancel_delayed_work_sync(&wm->ts_reader); |
| |
| /* Power down the digitiser (bypassing the cache for resume) */ |
| reg = wm97xx_reg_read(wm, AC97_WM97XX_DIGITISER2); |
| reg &= ~WM97XX_PRP_DET_DIG; |
| if (wm->input_dev->users) |
| reg |= suspend_mode; |
| wm->ac97->bus->ops->write(wm->ac97, AC97_WM97XX_DIGITISER2, reg); |
| |
| /* WM9713 has an additional power bit - turn it off if there |
| * are no users or if suspend mode is zero. */ |
| if (wm->id == WM9713_ID2 && |
| (!wm->input_dev->users || !suspend_mode)) { |
| reg = wm97xx_reg_read(wm, AC97_EXTENDED_MID) | 0x8000; |
| wm97xx_reg_write(wm, AC97_EXTENDED_MID, reg); |
| } |
| |
| return 0; |
| } |
| |
| static int wm97xx_resume(struct device *dev) |
| { |
| struct wm97xx *wm = dev_get_drvdata(dev); |
| |
| /* restore digitiser and gpios */ |
| if (wm->id == WM9713_ID2) { |
| wm97xx_reg_write(wm, AC97_WM9713_DIG1, wm->dig[0]); |
| wm97xx_reg_write(wm, 0x5a, wm->misc); |
| if (wm->input_dev->users) { |
| u16 reg; |
| reg = wm97xx_reg_read(wm, AC97_EXTENDED_MID) & 0x7fff; |
| wm97xx_reg_write(wm, AC97_EXTENDED_MID, reg); |
| } |
| } |
| |
| wm97xx_reg_write(wm, AC97_WM9713_DIG2, wm->dig[1]); |
| wm97xx_reg_write(wm, AC97_WM9713_DIG3, wm->dig[2]); |
| |
| wm97xx_reg_write(wm, AC97_GPIO_CFG, wm->gpio[0]); |
| wm97xx_reg_write(wm, AC97_GPIO_POLARITY, wm->gpio[1]); |
| wm97xx_reg_write(wm, AC97_GPIO_STICKY, wm->gpio[2]); |
| wm97xx_reg_write(wm, AC97_GPIO_WAKEUP, wm->gpio[3]); |
| wm97xx_reg_write(wm, AC97_GPIO_STATUS, wm->gpio[4]); |
| wm97xx_reg_write(wm, AC97_MISC_AFE, wm->gpio[5]); |
| |
| if (wm->input_dev->users && !wm->pen_irq) { |
| wm->ts_reader_interval = wm->ts_reader_min_interval; |
| queue_delayed_work(wm->ts_workq, &wm->ts_reader, |
| wm->ts_reader_interval); |
| } |
| |
| return 0; |
| } |
| |
| #else |
| #define wm97xx_suspend NULL |
| #define wm97xx_resume NULL |
| #endif |
| |
| /* |
| * Machine specific operations |
| */ |
| int wm97xx_register_mach_ops(struct wm97xx *wm, |
| struct wm97xx_mach_ops *mach_ops) |
| { |
| mutex_lock(&wm->codec_mutex); |
| if (wm->mach_ops) { |
| mutex_unlock(&wm->codec_mutex); |
| return -EINVAL; |
| } |
| wm->mach_ops = mach_ops; |
| mutex_unlock(&wm->codec_mutex); |
| |
| return 0; |
| } |
| EXPORT_SYMBOL_GPL(wm97xx_register_mach_ops); |
| |
| void wm97xx_unregister_mach_ops(struct wm97xx *wm) |
| { |
| mutex_lock(&wm->codec_mutex); |
| wm->mach_ops = NULL; |
| mutex_unlock(&wm->codec_mutex); |
| } |
| EXPORT_SYMBOL_GPL(wm97xx_unregister_mach_ops); |
| |
| static struct device_driver wm97xx_driver = { |
| .name = "wm97xx-ts", |
| .bus = &ac97_bus_type, |
| .owner = THIS_MODULE, |
| .probe = wm97xx_probe, |
| .remove = wm97xx_remove, |
| .suspend = wm97xx_suspend, |
| .resume = wm97xx_resume, |
| }; |
| |
| static int __init wm97xx_init(void) |
| { |
| return driver_register(&wm97xx_driver); |
| } |
| |
| static void __exit wm97xx_exit(void) |
| { |
| driver_unregister(&wm97xx_driver); |
| } |
| |
| module_init(wm97xx_init); |
| module_exit(wm97xx_exit); |
| |
| /* Module information */ |
| MODULE_AUTHOR("Liam Girdwood <liam.girdwood@wolfsonmicro.com>"); |
| MODULE_DESCRIPTION("WM97xx Core - Touch Screen / AUX ADC / GPIO Driver"); |
| MODULE_LICENSE("GPL"); |