static int stmp3xxx_ts_resume(struct platform_device *pdev)
{
#ifdef CONFIG_PM
if (!device_may_wakeup(&pdev->dev)) {
hw_lradc_use_channel(LRADC_CH2);
hw_lradc_use_channel(LRADC_CH3);
hw_lradc_use_channel(LRADC_CH5);
}
#endif
return 0;
}
static int mxskbd_resume(struct platform_device *pdev)
{
struct mxskbd_data *d = platform_get_drvdata(pdev);
__raw_writel(BM_LRADC_CTRL1_LRADC0_IRQ_EN << d->chan,
d->base + HW_LRADC_CTRL1_SET);
mxskbd_open(d->input);
hw_lradc_use_channel(d->chan);
mxskbd_hwinit(pdev);
return 0;
}
static int stmp3xxx_ts_probe(struct platform_device *pdev)
{
struct input_dev *idev;
struct stmp3xxx_ts_info *info;
int ret = 0;
struct resource *res;
idev = input_allocate_device();
info = kzalloc(sizeof(struct stmp3xxx_ts_info), GFP_KERNEL);
if (idev == NULL || info == NULL) {
ret = -ENOMEM;
goto out_nomem;
}
idev->name = "STMP3XXX touchscreen";
idev->evbit[0] = BIT(EV_ABS);
input_set_abs_params(idev, ABS_X, 0, 0xFFF, 0, 0);
input_set_abs_params(idev, ABS_Y, 0, 0xFFF, 0, 0);
input_set_abs_params(idev, ABS_PRESSURE, 0, 1, 0, 0);
ret = input_register_device(idev);
if (ret)
goto out_nomem;
info->idev = idev;
res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!res) {
printk(KERN_ERR "%s: couldn't get IRQ resource\n", __func__);
ret = -ENODEV;
goto out_nodev;
}
info->touch_irq = res->start;
res = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
if (!res) {
printk(KERN_ERR "%s: couldn't get IRQ resource\n", __func__);
ret = -ENODEV;
goto out_nodev;
}
info->device_irq = res->start;
ret = request_irq(info->touch_irq, ts_handler, IRQF_DISABLED,
"stmp3xxx_ts_touch", info);
if (ret)
goto out_nodev;
ret = request_irq(info->device_irq, ts_handler, IRQF_DISABLED,
"stmp3xxx_ts_dev", info);
if (ret) {
free_irq(info->touch_irq, info);
goto out_nodev;
}
enter_state_touch_detect(info);
hw_lradc_use_channel(LRADC_CH2);
hw_lradc_use_channel(LRADC_CH3);
hw_lradc_use_channel(LRADC_CH5);
hw_lradc_configure_channel(LRADC_CH2, 0, 0, 0);
hw_lradc_configure_channel(LRADC_CH3, 0, 0, 0);
hw_lradc_configure_channel(LRADC_CH5, 0, 0, 0);
/* Clear the accumulator & NUM_SAMPLES for the channels */
__raw_writel(0xFFFFFFFF, REGS_LRADC_BASE + HW_LRADC_CHn_CLR(LRADC_CH2));
__raw_writel(0xFFFFFFFF, REGS_LRADC_BASE + HW_LRADC_CHn_CLR(LRADC_CH3));
__raw_writel(0xFFFFFFFF, REGS_LRADC_BASE + HW_LRADC_CHn_CLR(LRADC_CH5));
hw_lradc_set_delay_trigger(LRADC_DELAY_TRIGGER_TOUCHSCREEN,
0x3c, 0, 0, 8);
__raw_writel(BM_LRADC_CTRL1_LRADC5_IRQ,
REGS_LRADC_BASE + HW_LRADC_CTRL1_CLR);
__raw_writel(BM_LRADC_CTRL1_TOUCH_DETECT_IRQ,
REGS_LRADC_BASE + HW_LRADC_CTRL1_CLR);
__raw_writel(BM_LRADC_CTRL1_LRADC5_IRQ_EN,
REGS_LRADC_BASE + HW_LRADC_CTRL1_SET);
__raw_writel(BM_LRADC_CTRL1_TOUCH_DETECT_IRQ_EN,
REGS_LRADC_BASE + HW_LRADC_CTRL1_SET);
platform_set_drvdata(pdev, info);
device_init_wakeup(&pdev->dev, 1);
goto out;
out_nodev:
input_free_device(idev);
out_nomem:
kfree(idev);
kfree(info);
out:
return ret;
}
static int __devinit mxskbd_probe(struct platform_device *pdev)
{
int err = 0;
struct resource *res;
struct mxskbd_data *d;
struct mxs_kbd_plat_data *plat_data;
plat_data = (struct mxs_kbd_plat_data *)pdev->dev.platform_data;
if (plat_data == NULL)
return -ENODEV;
/* Create and register the input driver. */
d = mxskbd_data_alloc(pdev, plat_data->keypair);
if (!d) {
dev_err(&pdev->dev, "Cannot allocate driver structures\n");
err = -ENOMEM;
goto err_out;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
err = -ENODEV;
goto err_out;
}
d->base = (unsigned int)IO_ADDRESS(res->start);
d->chan = plat_data->channel;
d->irq = platform_get_irq(pdev, 0);
d->btn_irq = platform_get_irq(pdev, 1);
d->btn_enable = plat_data->btn_enable;
d->btn_irq_stat = plat_data->btn_irq_stat;
d->btn_irq_ctrl = plat_data->btn_irq_ctrl;
platform_set_drvdata(pdev, d);
err = request_irq(d->irq, mxskbd_irq_handler,
IRQF_DISABLED, pdev->name, pdev);
if (err) {
dev_err(&pdev->dev, "Cannot request keypad IRQ\n");
goto err_free_dev;
}
if (d->btn_irq > 0) {
err = request_irq(d->btn_irq, mxskbd_irq_handler,
IRQF_DISABLED, pdev->name, pdev);
if (err) {
dev_err(&pdev->dev,
"Cannot request keybad detect IRQ\n");
goto err_free_irq;
}
}
/* Register the input device */
err = input_register_device(GET_INPUT_DEV(d));
if (err)
goto err_free_irq2;
/* these two have to be set after registering the input device */
d->input->rep[REP_DELAY] = delay1;
d->input->rep[REP_PERIOD] = delay2;
hw_lradc_use_channel(d->chan);
mxskbd_hwinit(pdev);
return 0;
err_free_irq2:
platform_set_drvdata(pdev, NULL);
if (d->btn_irq > 0)
free_irq(d->btn_irq, pdev);
err_free_irq:
free_irq(d->irq, pdev);
err_free_dev:
mxskbd_data_free(d);
err_out:
return err;
}
static int __devinit mxskbd_probe(struct platform_device *pdev)
{
int i;
int err = 0;
struct resource *res;
struct mxskbd_data *d;
struct mxs_kbd_plat_data *plat_data;
plat_data = (struct mxs_kbd_plat_data *)pdev->dev.platform_data;
if (plat_data == NULL)
return -ENODEV;
#ifdef CONFIG_HAS_WAKELOCK
wake_lock_init(&key_wake_lock, WAKE_LOCK_SUSPEND, "mxs-keypad");
#endif
/* Create and register the input driver. */
d = mxskbd_data_alloc(pdev, plat_data->keypair,
plat_data->keypair_offset);
if (!d) {
dev_err(&pdev->dev, "Cannot allocate driver structures\n");
err = -ENOMEM;
goto err_out;
}
_devdata = d;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res) {
err = -ENODEV;
goto err_out;
}
d->base = (unsigned int)IO_ADDRESS(res->start);
for (i = 0; i < MAX_CH; i++)
d->chan[i] = plat_data->channel[i];
d->btn_irq1 = platform_get_irq(pdev, 0);
platform_set_drvdata(pdev, d);
if (d->btn_irq1 > 0) {
err = request_irq(d->btn_irq1, mxskbd_irq_handler,
IRQF_DISABLED, pdev->name, pdev);
if (err) {
dev_err(&pdev->dev, "Cannot request keypad IRQ\n");
goto err_free_dev;
}
}
/* Register the input device */
err = input_register_device(GET_INPUT_DEV(d));
if (err)
goto err_free_dev;
/* these two have to be set after registering the input device */
d->input->rep[REP_DELAY] = delay1;
d->input->rep[REP_PERIOD] = delay2;
for (i = 0; i < MAX_CH; i++)
hw_lradc_use_channel(d->chan[i]);
mxskbd_hwinit(pdev);
#ifdef ENABLE_BACKLIGHT_GPIO_CONTROL
init_timer(&_bl_timer);
_bl_timer.function = _keypad_bl_timer_handler;
#endif
return 0;
err_free_dev:
if (d->btn_irq1 > 0)
free_irq(d->btn_irq1, pdev);
mxskbd_data_free(d);
err_out:
#ifdef CONFIG_HAS_WAKELOCK
wake_lock_destroy(&key_wake_lock);
#endif
return err;
}
