drivers/input/keyboard/bcm-keypad.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 // Copyright (C) 2014 Broadcom Corporation

 #include <linux/bitops.h>
 #include <linux/clk.h>
 #include <linux/gfp.h>
 #include <linux/io.h>
 #include <linux/input.h>
 #include <linux/input/matrix_keypad.h>
 #include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/stddef.h>
 #include <linux/types.h>

 #define DEFAULT_CLK_HZ			31250
 #define MAX_ROWS			8
 #define MAX_COLS			8

 /* Register/field definitions */
 #define KPCR_OFFSET			0x00000080
 #define KPCR_MODE			0x00000002
 #define KPCR_MODE_SHIFT			1
 #define KPCR_MODE_MASK			1
 #define KPCR_ENABLE			0x00000001
 #define KPCR_STATUSFILTERENABLE		0x00008000
 #define KPCR_STATUSFILTERTYPE_SHIFT	12
 #define KPCR_COLFILTERENABLE		0x00000800
 #define KPCR_COLFILTERTYPE_SHIFT	8
 #define KPCR_ROWWIDTH_SHIFT		20
 #define KPCR_COLUMNWIDTH_SHIFT		16

 #define KPIOR_OFFSET			0x00000084
 #define KPIOR_ROWOCONTRL_SHIFT		24
 #define KPIOR_ROWOCONTRL_MASK		0xFF000000
 #define KPIOR_COLUMNOCONTRL_SHIFT	16
 #define KPIOR_COLUMNOCONTRL_MASK	0x00FF0000
 #define KPIOR_COLUMN_IO_DATA_SHIFT	0

 #define KPEMR0_OFFSET			0x00000090
 #define KPEMR1_OFFSET			0x00000094
 #define KPEMR2_OFFSET			0x00000098
 #define KPEMR3_OFFSET			0x0000009C
 #define KPEMR_EDGETYPE_BOTH		3

 #define KPSSR0_OFFSET			0x000000A0
 #define KPSSR1_OFFSET			0x000000A4
 #define KPSSRN_OFFSET(reg_n)		(KPSSR0_OFFSET + 4 * (reg_n))
 #define KPIMR0_OFFSET			0x000000B0
 #define KPIMR1_OFFSET			0x000000B4
 #define KPICR0_OFFSET			0x000000B8
 #define KPICR1_OFFSET			0x000000BC
 #define KPICRN_OFFSET(reg_n)		(KPICR0_OFFSET + 4 * (reg_n))
 #define KPISR0_OFFSET			0x000000C0
 #define KPISR1_OFFSET			0x000000C4

 #define KPCR_STATUSFILTERTYPE_MAX	7
 #define KPCR_COLFILTERTYPE_MAX		7

 /* Macros to determine the row/column from a bit that is set in SSR0/1. */
 #define BIT_TO_ROW_SSRN(bit_nr, reg_n)	(((bit_nr) >> 3) + 4 * (reg_n))
 #define BIT_TO_COL(bit_nr)		((bit_nr) % 8)

 /* Structure representing various run-time entities */
 struct bcm_kp {
 	void __iomem *base;
 	int irq;
 	struct clk *clk;
 	struct input_dev *input_dev;
 	unsigned long last_state[2];
 	unsigned int n_rows;
 	unsigned int n_cols;
 	u32 kpcr;
 	u32 kpior;
 	u32 kpemr;
 	u32 imr0_val;
 	u32 imr1_val;
 };

 /*
  * Returns the keycode from the input device keymap given the row and
  * column.
  */
 static int bcm_kp_get_keycode(struct bcm_kp *kp, int row, int col)
 {
 	unsigned int row_shift = get_count_order(kp->n_cols);
 	unsigned short *keymap = kp->input_dev->keycode;

 	return keymap[MATRIX_SCAN_CODE(row, col, row_shift)];
 }

 static void bcm_kp_report_keys(struct bcm_kp *kp, int reg_num, int pull_mode)
 {
 	unsigned long state, change;
 	int bit_nr;
 	int key_press;
 	int row, col;
 	unsigned int keycode;

 	/* Clear interrupts */
 	writel(0xFFFFFFFF, kp->base + KPICRN_OFFSET(reg_num));

 	state = readl(kp->base + KPSSRN_OFFSET(reg_num));
 	change = kp->last_state[reg_num] ^ state;
 	kp->last_state[reg_num] = state;

 	for_each_set_bit(bit_nr, &change, BITS_PER_LONG) {
 		key_press = state & BIT(bit_nr);
 		/* The meaning of SSR register depends on pull mode. */
 		key_press = pull_mode ? !key_press : key_press;
 		row = BIT_TO_ROW_SSRN(bit_nr, reg_num);
 		col = BIT_TO_COL(bit_nr);
 		keycode = bcm_kp_get_keycode(kp, row, col);
 		input_report_key(kp->input_dev, keycode, key_press);
 	}
 }

 static irqreturn_t bcm_kp_isr_thread(int irq, void *dev_id)
 {
 	struct bcm_kp *kp = dev_id;
 	int pull_mode = (kp->kpcr >> KPCR_MODE_SHIFT) & KPCR_MODE_MASK;
 	int reg_num;

 	for (reg_num = 0; reg_num <= 1; reg_num++)
 		bcm_kp_report_keys(kp, reg_num, pull_mode);

 	input_sync(kp->input_dev);

 	return IRQ_HANDLED;
 }

 static int bcm_kp_start(struct bcm_kp *kp)
 {
 	int error;

 	if (kp->clk) {
 		error = clk_prepare_enable(kp->clk);
 		if (error)
 			return error;
 	}

 	writel(kp->kpior, kp->base + KPIOR_OFFSET);

 	writel(kp->imr0_val, kp->base + KPIMR0_OFFSET);
 	writel(kp->imr1_val, kp->base + KPIMR1_OFFSET);

 	writel(kp->kpemr, kp->base + KPEMR0_OFFSET);
 	writel(kp->kpemr, kp->base + KPEMR1_OFFSET);
 	writel(kp->kpemr, kp->base + KPEMR2_OFFSET);
 	writel(kp->kpemr, kp->base + KPEMR3_OFFSET);

 	writel(0xFFFFFFFF, kp->base + KPICR0_OFFSET);
 	writel(0xFFFFFFFF, kp->base + KPICR1_OFFSET);

 	kp->last_state[0] = readl(kp->base + KPSSR0_OFFSET);
 	kp->last_state[0] = readl(kp->base + KPSSR1_OFFSET);

 	writel(kp->kpcr | KPCR_ENABLE, kp->base + KPCR_OFFSET);

 	return 0;
 }

 static void bcm_kp_stop(const struct bcm_kp *kp)
 {
 	u32 val;

 	val = readl(kp->base + KPCR_OFFSET);
 	val &= ~KPCR_ENABLE;
 	writel(0, kp->base + KPCR_OFFSET);
 	writel(0, kp->base + KPIMR0_OFFSET);
 	writel(0, kp->base + KPIMR1_OFFSET);
 	writel(0xFFFFFFFF, kp->base + KPICR0_OFFSET);
 	writel(0xFFFFFFFF, kp->base + KPICR1_OFFSET);

 	clk_disable_unprepare(kp->clk);
 }

 static int bcm_kp_open(struct input_dev *dev)
 {
 	struct bcm_kp *kp = input_get_drvdata(dev);

 	return bcm_kp_start(kp);
 }

 static void bcm_kp_close(struct input_dev *dev)
 {
 	struct bcm_kp *kp = input_get_drvdata(dev);

 	bcm_kp_stop(kp);
 }

 static int bcm_kp_matrix_key_parse_dt(struct bcm_kp *kp)
 {
 	struct device *dev = kp->input_dev->dev.parent;
 	struct device_node *np = dev->of_node;
 	int error;
 	unsigned int dt_val;
 	unsigned int i;
 	unsigned int num_rows, col_mask, rows_set;

 	/* Initialize the KPCR Keypad Configuration Register */
 	kp->kpcr = KPCR_STATUSFILTERENABLE | KPCR_COLFILTERENABLE;

 	error = matrix_keypad_parse_properties(dev, &kp->n_rows, &kp->n_cols);
 	if (error) {
 		dev_err(dev, "failed to parse kp params\n");
 		return error;
 	}

 	/* Set row width for the ASIC block. */
 	kp->kpcr |= (kp->n_rows - 1) << KPCR_ROWWIDTH_SHIFT;

 	/* Set column width for the ASIC block. */
 	kp->kpcr |= (kp->n_cols - 1) << KPCR_COLUMNWIDTH_SHIFT;

 	/* Configure the IMR registers */

 	/*
 	 * IMR registers contain interrupt enable bits for 8x8 matrix
 	 * IMR0 register format: <row3> <row2> <row1> <row0>
 	 * IMR1 register format: <row7> <row6> <row5> <row4>
 	 */
 	col_mask = (1 << (kp->n_cols)) - 1;
 	num_rows = kp->n_rows;

 	/* Set column bits in rows 0 to 3 in IMR0 */
 	kp->imr0_val = col_mask;

 	rows_set = 1;
 	while (--num_rows && rows_set++ < 4)
 		kp->imr0_val |= kp->imr0_val << MAX_COLS;

 	/* Set column bits in rows 4 to 7 in IMR1 */
 	kp->imr1_val = 0;
 	if (num_rows) {
 		kp->imr1_val = col_mask;
 		while (--num_rows)
 			kp->imr1_val |= kp->imr1_val << MAX_COLS;
 	}

 	/* Initialize the KPEMR Keypress Edge Mode Registers */
 	/* Trigger on both edges */
 	kp->kpemr = 0;
 	for (i = 0; i <= 30; i += 2)
 		kp->kpemr |= (KPEMR_EDGETYPE_BOTH << i);

 	/*
 	 * Obtain the Status filter debounce value and verify against the
 	 * possible values specified in the DT binding.
 	 */
 	of_property_read_u32(np, "status-debounce-filter-period", &dt_val);

 	if (dt_val > KPCR_STATUSFILTERTYPE_MAX) {
 		dev_err(dev, "Invalid Status filter debounce value %d\n",
 			dt_val);
 		return -EINVAL;
 	}

 	kp->kpcr |= dt_val << KPCR_STATUSFILTERTYPE_SHIFT;

 	/*
 	 * Obtain the Column filter debounce value and verify against the
 	 * possible values specified in the DT binding.
 	 */
 	of_property_read_u32(np, "col-debounce-filter-period", &dt_val);

 	if (dt_val > KPCR_COLFILTERTYPE_MAX) {
 		dev_err(dev, "Invalid Column filter debounce value %d\n",
 			dt_val);
 		return -EINVAL;
 	}

 	kp->kpcr |= dt_val << KPCR_COLFILTERTYPE_SHIFT;

 	/*
 	 * Determine between the row and column,
 	 * which should be configured as output.
 	 */
 	if (of_property_read_bool(np, "row-output-enabled")) {
 		/*
 		* Set RowOContrl or ColumnOContrl in KPIOR
 		* to the number of pins to drive as outputs
 		*/
 		kp->kpior = ((1 << kp->n_rows) - 1) <<
 				KPIOR_ROWOCONTRL_SHIFT;
 	} else {
 		kp->kpior = ((1 << kp->n_cols) - 1) <<
 				KPIOR_COLUMNOCONTRL_SHIFT;
 	}

 	/*
 	 * Determine if the scan pull up needs to be enabled
 	 */
 	if (of_property_read_bool(np, "pull-up-enabled"))
 		kp->kpcr |= KPCR_MODE;

 	dev_dbg(dev, "n_rows=%d n_col=%d kpcr=%x kpior=%x kpemr=%x\n",
 		kp->n_rows, kp->n_cols,
 		kp->kpcr, kp->kpior, kp->kpemr);

 	return 0;
 }


 static int bcm_kp_probe(struct platform_device *pdev)
 {
 	struct bcm_kp *kp;
 	struct input_dev *input_dev;
 	int error;

 	kp = devm_kzalloc(&pdev->dev, sizeof(*kp), GFP_KERNEL);
 	if (!kp)
 		return -ENOMEM;

 	input_dev = devm_input_allocate_device(&pdev->dev);
 	if (!input_dev) {
 		dev_err(&pdev->dev, "failed to allocate the input device\n");
 		return -ENOMEM;
 	}

 	__set_bit(EV_KEY, input_dev->evbit);

 	/* Enable auto repeat feature of Linux input subsystem */
 	if (of_property_read_bool(pdev->dev.of_node, "autorepeat"))
 		__set_bit(EV_REP, input_dev->evbit);

 	input_dev->name = pdev->name;
 	input_dev->phys = "keypad/input0";
 	input_dev->dev.parent = &pdev->dev;
 	input_dev->open = bcm_kp_open;
 	input_dev->close = bcm_kp_close;

 	input_dev->id.bustype = BUS_HOST;
 	input_dev->id.vendor = 0x0001;
 	input_dev->id.product = 0x0001;
 	input_dev->id.version = 0x0100;

 	input_set_drvdata(input_dev, kp);

 	kp->input_dev = input_dev;

 	error = bcm_kp_matrix_key_parse_dt(kp);
 	if (error)
 		return error;

 	error = matrix_keypad_build_keymap(NULL, NULL,
 					   kp->n_rows, kp->n_cols,
 					   NULL, input_dev);
 	if (error) {
 		dev_err(&pdev->dev, "failed to build keymap\n");
 		return error;
 	}

 	kp->base = devm_platform_ioremap_resource(pdev, 0);
 	if (IS_ERR(kp->base))
 		return PTR_ERR(kp->base);

 	/* Enable clock */
 	kp->clk = devm_clk_get_optional(&pdev->dev, "peri_clk");
 	if (IS_ERR(kp->clk)) {
 		return dev_err_probe(&pdev->dev, PTR_ERR(kp->clk), "Failed to get clock\n");
 	} else if (!kp->clk) {
 		dev_dbg(&pdev->dev, "No clock specified. Assuming it's enabled\n");
 	} else {
 		unsigned int desired_rate;
 		long actual_rate;

 		error = of_property_read_u32(pdev->dev.of_node,
 					     "clock-frequency", &desired_rate);
 		if (error < 0)
 			desired_rate = DEFAULT_CLK_HZ;

 		actual_rate = clk_round_rate(kp->clk, desired_rate);
 		if (actual_rate <= 0)
 			return -EINVAL;

 		error = clk_set_rate(kp->clk, actual_rate);
 		if (error)
 			return error;

 		error = clk_prepare_enable(kp->clk);
 		if (error)
 			return error;
 	}

 	/* Put the kp into a known sane state */
 	bcm_kp_stop(kp);

 	kp->irq = platform_get_irq(pdev, 0);
 	if (kp->irq < 0)
 		return -EINVAL;

 	error = devm_request_threaded_irq(&pdev->dev, kp->irq,
 					  NULL, bcm_kp_isr_thread,
 					  IRQF_ONESHOT, pdev->name, kp);
 	if (error) {
 		dev_err(&pdev->dev, "failed to request IRQ\n");
 		return error;
 	}

 	error = input_register_device(input_dev);
 	if (error) {
 		dev_err(&pdev->dev, "failed to register input device\n");
 		return error;
 	}

 	return 0;
 }

 static const struct of_device_id bcm_kp_of_match[] = {
 	{ .compatible = "brcm,bcm-keypad" },
 	{ },
 };
 MODULE_DEVICE_TABLE(of, bcm_kp_of_match);

 static struct platform_driver bcm_kp_device_driver = {
 	.probe		= bcm_kp_probe,
 	.driver		= {
 		.name	= "bcm-keypad",
 		.of_match_table = of_match_ptr(bcm_kp_of_match),
 	}
 };

 module_platform_driver(bcm_kp_device_driver);

 MODULE_AUTHOR("Broadcom Corporation");
 MODULE_DESCRIPTION("BCM Keypad Driver");
 MODULE_LICENSE("GPL v2");
	// SPDX-License-Identifier: GPL-2.0-only
	// Copyright (C) 2014 Broadcom Corporation

	#include <linux/bitops.h>
	#include <linux/clk.h>
	#include <linux/gfp.h>
	#include <linux/io.h>
	#include <linux/input.h>
	#include <linux/input/matrix_keypad.h>
	#include <linux/interrupt.h>
	#include <linux/module.h>
	#include <linux/of.h>
	#include <linux/platform_device.h>
	#include <linux/stddef.h>
	#include <linux/types.h>

	#define DEFAULT_CLK_HZ 31250
	#define MAX_ROWS 8
	#define MAX_COLS 8

	/* Register/field definitions */
	#define KPCR_OFFSET 0x00000080
	#define KPCR_MODE 0x00000002
	#define KPCR_MODE_SHIFT 1
	#define KPCR_MODE_MASK 1
	#define KPCR_ENABLE 0x00000001
	#define KPCR_STATUSFILTERENABLE 0x00008000
	#define KPCR_STATUSFILTERTYPE_SHIFT 12
	#define KPCR_COLFILTERENABLE 0x00000800
	#define KPCR_COLFILTERTYPE_SHIFT 8
	#define KPCR_ROWWIDTH_SHIFT 20
	#define KPCR_COLUMNWIDTH_SHIFT 16

	#define KPIOR_OFFSET 0x00000084
	#define KPIOR_ROWOCONTRL_SHIFT 24
	#define KPIOR_ROWOCONTRL_MASK 0xFF000000
	#define KPIOR_COLUMNOCONTRL_SHIFT 16
	#define KPIOR_COLUMNOCONTRL_MASK 0x00FF0000
	#define KPIOR_COLUMN_IO_DATA_SHIFT 0

	#define KPEMR0_OFFSET 0x00000090
	#define KPEMR1_OFFSET 0x00000094
	#define KPEMR2_OFFSET 0x00000098
	#define KPEMR3_OFFSET 0x0000009C
	#define KPEMR_EDGETYPE_BOTH 3

	#define KPSSR0_OFFSET 0x000000A0
	#define KPSSR1_OFFSET 0x000000A4
	#define KPSSRN_OFFSET(reg_n) (KPSSR0_OFFSET + 4 * (reg_n))
	#define KPIMR0_OFFSET 0x000000B0
	#define KPIMR1_OFFSET 0x000000B4
	#define KPICR0_OFFSET 0x000000B8
	#define KPICR1_OFFSET 0x000000BC
	#define KPICRN_OFFSET(reg_n) (KPICR0_OFFSET + 4 * (reg_n))
	#define KPISR0_OFFSET 0x000000C0
	#define KPISR1_OFFSET 0x000000C4

	#define KPCR_STATUSFILTERTYPE_MAX 7
	#define KPCR_COLFILTERTYPE_MAX 7

	/* Macros to determine the row/column from a bit that is set in SSR0/1. */
	#define BIT_TO_ROW_SSRN(bit_nr, reg_n) (((bit_nr) >> 3) + 4 * (reg_n))
	#define BIT_TO_COL(bit_nr) ((bit_nr) % 8)

	/* Structure representing various run-time entities */
	struct bcm_kp {
	void __iomem *base;
	int irq;
	struct clk *clk;
	struct input_dev *input_dev;
	unsigned long last_state[2];
	unsigned int n_rows;
	unsigned int n_cols;
	u32 kpcr;
	u32 kpior;
	u32 kpemr;
	u32 imr0_val;
	u32 imr1_val;
	};

	/*
	* Returns the keycode from the input device keymap given the row and
	* column.
	*/
	static int bcm_kp_get_keycode(struct bcm_kp *kp, int row, int col)
	{
	unsigned int row_shift = get_count_order(kp->n_cols);
	unsigned short *keymap = kp->input_dev->keycode;

	return keymap[MATRIX_SCAN_CODE(row, col, row_shift)];
	}

	static void bcm_kp_report_keys(struct bcm_kp *kp, int reg_num, int pull_mode)
	{
	unsigned long state, change;
	int bit_nr;
	int key_press;
	int row, col;
	unsigned int keycode;

	/* Clear interrupts */
	writel(0xFFFFFFFF, kp->base + KPICRN_OFFSET(reg_num));

	state = readl(kp->base + KPSSRN_OFFSET(reg_num));
	change = kp->last_state[reg_num] ^ state;
	kp->last_state[reg_num] = state;

	for_each_set_bit(bit_nr, &change, BITS_PER_LONG) {
	key_press = state & BIT(bit_nr);
	/* The meaning of SSR register depends on pull mode. */
	key_press = pull_mode ? !key_press : key_press;
	row = BIT_TO_ROW_SSRN(bit_nr, reg_num);
	col = BIT_TO_COL(bit_nr);
	keycode = bcm_kp_get_keycode(kp, row, col);
	input_report_key(kp->input_dev, keycode, key_press);
	}
	}

	static irqreturn_t bcm_kp_isr_thread(int irq, void *dev_id)
	{
	struct bcm_kp *kp = dev_id;
	int pull_mode = (kp->kpcr >> KPCR_MODE_SHIFT) & KPCR_MODE_MASK;
	int reg_num;

	for (reg_num = 0; reg_num <= 1; reg_num++)
	bcm_kp_report_keys(kp, reg_num, pull_mode);

	input_sync(kp->input_dev);

	return IRQ_HANDLED;
	}

	static int bcm_kp_start(struct bcm_kp *kp)
	{
	int error;

	if (kp->clk) {
	error = clk_prepare_enable(kp->clk);
	if (error)
	return error;
	}

	writel(kp->kpior, kp->base + KPIOR_OFFSET);

	writel(kp->imr0_val, kp->base + KPIMR0_OFFSET);
	writel(kp->imr1_val, kp->base + KPIMR1_OFFSET);

	writel(kp->kpemr, kp->base + KPEMR0_OFFSET);
	writel(kp->kpemr, kp->base + KPEMR1_OFFSET);
	writel(kp->kpemr, kp->base + KPEMR2_OFFSET);
	writel(kp->kpemr, kp->base + KPEMR3_OFFSET);

	writel(0xFFFFFFFF, kp->base + KPICR0_OFFSET);
	writel(0xFFFFFFFF, kp->base + KPICR1_OFFSET);

	kp->last_state[0] = readl(kp->base + KPSSR0_OFFSET);
	kp->last_state[0] = readl(kp->base + KPSSR1_OFFSET);

	writel(kp->kpcr \| KPCR_ENABLE, kp->base + KPCR_OFFSET);

	return 0;
	}

	static void bcm_kp_stop(const struct bcm_kp *kp)
	{
	u32 val;

	val = readl(kp->base + KPCR_OFFSET);
	val &= ~KPCR_ENABLE;
	writel(0, kp->base + KPCR_OFFSET);
	writel(0, kp->base + KPIMR0_OFFSET);
	writel(0, kp->base + KPIMR1_OFFSET);
	writel(0xFFFFFFFF, kp->base + KPICR0_OFFSET);
	writel(0xFFFFFFFF, kp->base + KPICR1_OFFSET);

	clk_disable_unprepare(kp->clk);
	}

	static int bcm_kp_open(struct input_dev *dev)
	{
	struct bcm_kp *kp = input_get_drvdata(dev);

	return bcm_kp_start(kp);
	}

	static void bcm_kp_close(struct input_dev *dev)
	{
	struct bcm_kp *kp = input_get_drvdata(dev);

	bcm_kp_stop(kp);
	}

	static int bcm_kp_matrix_key_parse_dt(struct bcm_kp *kp)
	{
	struct device *dev = kp->input_dev->dev.parent;
	struct device_node *np = dev->of_node;
	int error;
	unsigned int dt_val;
	unsigned int i;
	unsigned int num_rows, col_mask, rows_set;

	/* Initialize the KPCR Keypad Configuration Register */
	kp->kpcr = KPCR_STATUSFILTERENABLE \| KPCR_COLFILTERENABLE;

	error = matrix_keypad_parse_properties(dev, &kp->n_rows, &kp->n_cols);
	if (error) {
	dev_err(dev, "failed to parse kp params\n");
	return error;
	}

	/* Set row width for the ASIC block. */
	kp->kpcr \|= (kp->n_rows - 1) << KPCR_ROWWIDTH_SHIFT;

	/* Set column width for the ASIC block. */
	kp->kpcr \|= (kp->n_cols - 1) << KPCR_COLUMNWIDTH_SHIFT;

	/* Configure the IMR registers */

	/*
	* IMR registers contain interrupt enable bits for 8x8 matrix
	* IMR0 register format: <row3> <row2> <row1> <row0>
	* IMR1 register format: <row7> <row6> <row5> <row4>
	*/
	col_mask = (1 << (kp->n_cols)) - 1;
	num_rows = kp->n_rows;

	/* Set column bits in rows 0 to 3 in IMR0 */
	kp->imr0_val = col_mask;

	rows_set = 1;
	while (--num_rows && rows_set++ < 4)
	kp->imr0_val \|= kp->imr0_val << MAX_COLS;

	/* Set column bits in rows 4 to 7 in IMR1 */
	kp->imr1_val = 0;
	if (num_rows) {
	kp->imr1_val = col_mask;
	while (--num_rows)
	kp->imr1_val \|= kp->imr1_val << MAX_COLS;
	}

	/* Initialize the KPEMR Keypress Edge Mode Registers */
	/* Trigger on both edges */
	kp->kpemr = 0;
	for (i = 0; i <= 30; i += 2)
	kp->kpemr \|= (KPEMR_EDGETYPE_BOTH << i);

	/*
	* Obtain the Status filter debounce value and verify against the
	* possible values specified in the DT binding.
	*/
	of_property_read_u32(np, "status-debounce-filter-period", &dt_val);

	if (dt_val > KPCR_STATUSFILTERTYPE_MAX) {
	dev_err(dev, "Invalid Status filter debounce value %d\n",
	dt_val);
	return -EINVAL;
	}

	kp->kpcr \|= dt_val << KPCR_STATUSFILTERTYPE_SHIFT;

	/*
	* Obtain the Column filter debounce value and verify against the
	* possible values specified in the DT binding.
	*/
	of_property_read_u32(np, "col-debounce-filter-period", &dt_val);

	if (dt_val > KPCR_COLFILTERTYPE_MAX) {
	dev_err(dev, "Invalid Column filter debounce value %d\n",
	dt_val);
	return -EINVAL;
	}

	kp->kpcr \|= dt_val << KPCR_COLFILTERTYPE_SHIFT;

	/*
	* Determine between the row and column,
	* which should be configured as output.
	*/
	if (of_property_read_bool(np, "row-output-enabled")) {
	/*
	* Set RowOContrl or ColumnOContrl in KPIOR
	* to the number of pins to drive as outputs
	*/
	kp->kpior = ((1 << kp->n_rows) - 1) <<
	KPIOR_ROWOCONTRL_SHIFT;
	} else {
	kp->kpior = ((1 << kp->n_cols) - 1) <<
	KPIOR_COLUMNOCONTRL_SHIFT;
	}

	/*
	* Determine if the scan pull up needs to be enabled
	*/
	if (of_property_read_bool(np, "pull-up-enabled"))
	kp->kpcr \|= KPCR_MODE;

	dev_dbg(dev, "n_rows=%d n_col=%d kpcr=%x kpior=%x kpemr=%x\n",
	kp->n_rows, kp->n_cols,
	kp->kpcr, kp->kpior, kp->kpemr);

	return 0;
	}


	static int bcm_kp_probe(struct platform_device *pdev)
	{
	struct bcm_kp *kp;
	struct input_dev *input_dev;
	int error;

	kp = devm_kzalloc(&pdev->dev, sizeof(*kp), GFP_KERNEL);
	if (!kp)
	return -ENOMEM;

	input_dev = devm_input_allocate_device(&pdev->dev);
	if (!input_dev) {
	dev_err(&pdev->dev, "failed to allocate the input device\n");
	return -ENOMEM;
	}

	__set_bit(EV_KEY, input_dev->evbit);

	/* Enable auto repeat feature of Linux input subsystem */
	if (of_property_read_bool(pdev->dev.of_node, "autorepeat"))
	__set_bit(EV_REP, input_dev->evbit);

	input_dev->name = pdev->name;
	input_dev->phys = "keypad/input0";
	input_dev->dev.parent = &pdev->dev;
	input_dev->open = bcm_kp_open;
	input_dev->close = bcm_kp_close;

	input_dev->id.bustype = BUS_HOST;
	input_dev->id.vendor = 0x0001;
	input_dev->id.product = 0x0001;
	input_dev->id.version = 0x0100;

	input_set_drvdata(input_dev, kp);

	kp->input_dev = input_dev;

	error = bcm_kp_matrix_key_parse_dt(kp);
	if (error)
	return error;

	error = matrix_keypad_build_keymap(NULL, NULL,
	kp->n_rows, kp->n_cols,
	NULL, input_dev);
	if (error) {
	dev_err(&pdev->dev, "failed to build keymap\n");
	return error;
	}

	kp->base = devm_platform_ioremap_resource(pdev, 0);
	if (IS_ERR(kp->base))
	return PTR_ERR(kp->base);

	/* Enable clock */
	kp->clk = devm_clk_get_optional(&pdev->dev, "peri_clk");
	if (IS_ERR(kp->clk)) {
	return dev_err_probe(&pdev->dev, PTR_ERR(kp->clk), "Failed to get clock\n");
	} else if (!kp->clk) {
	dev_dbg(&pdev->dev, "No clock specified. Assuming it's enabled\n");
	} else {
	unsigned int desired_rate;
	long actual_rate;

	error = of_property_read_u32(pdev->dev.of_node,
	"clock-frequency", &desired_rate);
	if (error < 0)
	desired_rate = DEFAULT_CLK_HZ;

	actual_rate = clk_round_rate(kp->clk, desired_rate);
	if (actual_rate <= 0)
	return -EINVAL;

	error = clk_set_rate(kp->clk, actual_rate);
	if (error)
	return error;

	error = clk_prepare_enable(kp->clk);
	if (error)
	return error;
	}

	/* Put the kp into a known sane state */
	bcm_kp_stop(kp);

	kp->irq = platform_get_irq(pdev, 0);
	if (kp->irq < 0)
	return -EINVAL;

	error = devm_request_threaded_irq(&pdev->dev, kp->irq,
	NULL, bcm_kp_isr_thread,
	IRQF_ONESHOT, pdev->name, kp);
	if (error) {
	dev_err(&pdev->dev, "failed to request IRQ\n");
	return error;
	}

	error = input_register_device(input_dev);
	if (error) {
	dev_err(&pdev->dev, "failed to register input device\n");
	return error;
	}

	return 0;
	}

	static const struct of_device_id bcm_kp_of_match[] = {
	{ .compatible = "brcm,bcm-keypad" },
	{ },
	};
	MODULE_DEVICE_TABLE(of, bcm_kp_of_match);

	static struct platform_driver bcm_kp_device_driver = {
	.probe = bcm_kp_probe,
	.driver = {
	.name = "bcm-keypad",
	.of_match_table = of_match_ptr(bcm_kp_of_match),
	}
	};

	module_platform_driver(bcm_kp_device_driver);

	MODULE_AUTHOR("Broadcom Corporation");
	MODULE_DESCRIPTION("BCM Keypad Driver");
	MODULE_LICENSE("GPL v2");