cregit-Linux how code gets into the kernel

Release 4.11 drivers/input/misc/palmas-pwrbutton.c

/*
 * Texas Instruments' Palmas Power Button Input Driver
 *
 * Copyright (C) 2012-2014 Texas Instruments Incorporated - http://www.ti.com/
 *      Girish S Ghongdemath
 *      Nishanth Menon
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
 * kind, whether express or implied; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/init.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/mfd/palmas.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/slab.h>


#define PALMAS_LPK_TIME_MASK		0x0c

#define PALMAS_PWRON_DEBOUNCE_MASK	0x03

#define PALMAS_PWR_KEY_Q_TIME_MS	20

/**
 * struct palmas_pwron - Palmas power on data
 * @palmas:             pointer to palmas device
 * @input_dev:          pointer to input device
 * @input_work:         work for detecting release of key
 * @irq:                irq that we are hooked on to
 */

struct palmas_pwron {
	
struct palmas *palmas;
	
struct input_dev *input_dev;
	
struct delayed_work input_work;
	
int irq;
};

/**
 * struct palmas_pwron_config - configuration of palmas power on
 * @long_press_time_val:        value for long press h/w shutdown event
 * @pwron_debounce_val:         value for debounce of power button
 */

struct palmas_pwron_config {
	
u8 long_press_time_val;
	
u8 pwron_debounce_val;
};

/**
 * palmas_power_button_work() - Detects the button release event
 * @work:       work item to detect button release
 */

static void palmas_power_button_work(struct work_struct *work) { struct palmas_pwron *pwron = container_of(work, struct palmas_pwron, input_work.work); struct input_dev *input_dev = pwron->input_dev; unsigned int reg; int error; error = palmas_read(pwron->palmas, PALMAS_INTERRUPT_BASE, PALMAS_INT1_LINE_STATE, &reg); if (error) { dev_err(input_dev->dev.parent, "Cannot read palmas PWRON status: %d\n", error); } else if (reg & BIT(1)) { /* The button is released, report event. */ input_report_key(input_dev, KEY_POWER, 0); input_sync(input_dev); } else { /* The button is still depressed, keep checking. */ schedule_delayed_work(&pwron->input_work, msecs_to_jiffies(PALMAS_PWR_KEY_Q_TIME_MS)); } }

Contributors

PersonTokensPropCommitsCommitProp
Nishanth Menon123100.00%1100.00%
Total123100.00%1100.00%

/** * pwron_irq() - button press isr * @irq: irq * @palmas_pwron: pwron struct * * Return: IRQ_HANDLED */
static irqreturn_t pwron_irq(int irq, void *palmas_pwron) { struct palmas_pwron *pwron = palmas_pwron; struct input_dev *input_dev = pwron->input_dev; input_report_key(input_dev, KEY_POWER, 1); pm_wakeup_event(input_dev->dev.parent, 0); input_sync(input_dev); mod_delayed_work(system_wq, &pwron->input_work, msecs_to_jiffies(PALMAS_PWR_KEY_Q_TIME_MS)); return IRQ_HANDLED; }

Contributors

PersonTokensPropCommitsCommitProp
Nishanth Menon72100.00%1100.00%
Total72100.00%1100.00%

/** * palmas_pwron_params_ofinit() - device tree parameter parser * @dev: palmas button device * @config: configuration params that this fills up */
static void palmas_pwron_params_ofinit(struct device *dev, struct palmas_pwron_config *config) { struct device_node *np; u32 val; int i, error; u8 lpk_times[] = { 6, 8, 10, 12 }; int pwr_on_deb_ms[] = { 15, 100, 500, 1000 }; memset(config, 0, sizeof(*config)); /* Default config parameters */ config->long_press_time_val = ARRAY_SIZE(lpk_times) - 1; np = dev->of_node; if (!np) return; error = of_property_read_u32(np, "ti,palmas-long-press-seconds", &val); if (!error) { for (i = 0; i < ARRAY_SIZE(lpk_times); i++) { if (val <= lpk_times[i]) { config->long_press_time_val = i; break; } } } error = of_property_read_u32(np, "ti,palmas-pwron-debounce-milli-seconds", &val); if (!error) { for (i = 0; i < ARRAY_SIZE(pwr_on_deb_ms); i++) { if (val <= pwr_on_deb_ms[i]) { config->pwron_debounce_val = i; break; } } } dev_info(dev, "h/w controlled shutdown duration=%d seconds\n", lpk_times[config->long_press_time_val]); }

Contributors

PersonTokensPropCommitsCommitProp
Nishanth Menon218100.00%1100.00%
Total218100.00%1100.00%

/** * palmas_pwron_probe() - probe * @pdev: platform device for the button * * Return: 0 for successful probe else appropriate error */
static int palmas_pwron_probe(struct platform_device *pdev) { struct palmas *palmas = dev_get_drvdata(pdev->dev.parent); struct device *dev = &pdev->dev; struct input_dev *input_dev; struct palmas_pwron *pwron; struct palmas_pwron_config config; int val; int error; palmas_pwron_params_ofinit(dev, &config); pwron = kzalloc(sizeof(*pwron), GFP_KERNEL); if (!pwron) return -ENOMEM; input_dev = input_allocate_device(); if (!input_dev) { dev_err(dev, "Can't allocate power button\n"); error = -ENOMEM; goto err_free_mem; } input_dev->name = "palmas_pwron"; input_dev->phys = "palmas_pwron/input0"; input_dev->dev.parent = dev; input_set_capability(input_dev, EV_KEY, KEY_POWER); /* * Setup default hardware shutdown option (long key press) * and debounce. */ val = config.long_press_time_val << __ffs(PALMAS_LPK_TIME_MASK); val |= config.pwron_debounce_val << __ffs(PALMAS_PWRON_DEBOUNCE_MASK); error = palmas_update_bits(palmas, PALMAS_PMU_CONTROL_BASE, PALMAS_LONG_PRESS_KEY, PALMAS_LPK_TIME_MASK | PALMAS_PWRON_DEBOUNCE_MASK, val); if (error) { dev_err(dev, "LONG_PRESS_KEY_UPDATE failed: %d\n", error); goto err_free_input; } pwron->palmas = palmas; pwron->input_dev = input_dev; INIT_DELAYED_WORK(&pwron->input_work, palmas_power_button_work); pwron->irq = platform_get_irq(pdev, 0); error = request_threaded_irq(pwron->irq, NULL, pwron_irq, IRQF_TRIGGER_HIGH | IRQF_TRIGGER_LOW | IRQF_ONESHOT, dev_name(dev), pwron); if (error) { dev_err(dev, "Can't get IRQ for pwron: %d\n", error); goto err_free_input; } error = input_register_device(input_dev); if (error) { dev_err(dev, "Can't register power button: %d\n", error); goto err_free_irq; } platform_set_drvdata(pdev, pwron); device_init_wakeup(dev, true); return 0; err_free_irq: cancel_delayed_work_sync(&pwron->input_work); free_irq(pwron->irq, pwron); err_free_input: input_free_device(input_dev); err_free_mem: kfree(pwron); return error; }

Contributors

PersonTokensPropCommitsCommitProp
Nishanth Menon354100.00%2100.00%
Total354100.00%2100.00%

/** * palmas_pwron_remove() - Cleanup on removal * @pdev: platform device for the button * * Return: 0 */
static int palmas_pwron_remove(struct platform_device *pdev) { struct palmas_pwron *pwron = platform_get_drvdata(pdev); free_irq(pwron->irq, pwron); cancel_delayed_work_sync(&pwron->input_work); input_unregister_device(pwron->input_dev); kfree(pwron); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Nishanth Menon53100.00%1100.00%
Total53100.00%1100.00%

/** * palmas_pwron_suspend() - suspend handler * @dev: power button device * * Cancel all pending work items for the power button, setup irq for wakeup * * Return: 0 */
static int __maybe_unused palmas_pwron_suspend(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); struct palmas_pwron *pwron = platform_get_drvdata(pdev); cancel_delayed_work_sync(&pwron->input_work); if (device_may_wakeup(dev)) enable_irq_wake(pwron->irq); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Nishanth Menon5698.25%150.00%
Jingoo Han11.75%150.00%
Total57100.00%2100.00%

/** * palmas_pwron_resume() - resume handler * @dev: power button device * * Just disable the wakeup capability of irq here. * * Return: 0 */
static int __maybe_unused palmas_pwron_resume(struct device *dev) { struct platform_device *pdev = to_platform_device(dev); struct palmas_pwron *pwron = platform_get_drvdata(pdev); if (device_may_wakeup(dev)) disable_irq_wake(pwron->irq); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
Nishanth Menon4897.96%150.00%
Jingoo Han12.04%150.00%
Total49100.00%2100.00%

static SIMPLE_DEV_PM_OPS(palmas_pwron_pm, palmas_pwron_suspend, palmas_pwron_resume); #ifdef CONFIG_OF static const struct of_device_id of_palmas_pwr_match[] = { { .compatible = "ti,palmas-pwrbutton" }, { }, }; MODULE_DEVICE_TABLE(of, of_palmas_pwr_match); #endif static struct platform_driver palmas_pwron_driver = { .probe = palmas_pwron_probe, .remove = palmas_pwron_remove, .driver = { .name = "palmas_pwrbutton", .of_match_table = of_match_ptr(of_palmas_pwr_match), .pm = &palmas_pwron_pm, }, }; module_platform_driver(palmas_pwron_driver); MODULE_ALIAS("platform:palmas-pwrbutton"); MODULE_DESCRIPTION("Palmas Power Button"); MODULE_LICENSE("GPL v2"); MODULE_AUTHOR("Texas Instruments Inc.");

Overall Contributors

PersonTokensPropCommitsCommitProp
Nishanth Menon111199.73%360.00%
Jingoo Han20.18%120.00%
Fabian Frederick10.09%120.00%
Total1114100.00%5100.00%
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.