Commit 7254a298 authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

Merge tag 'counter-updates-for-6.11' of... 

Merge tag 'counter-updates-for-6.11' of ssh://gitolite.kernel.org/pub/scm/linux/kernel/git/wbg/counter into char-misc-next

William writes:

Counter updates for 6.11

Primarily consists of cleanups and updates for ti-eqep; ti-eqep now
supports over/underflow events and can be build for K3 devices. In
addition, ftm-quaddec is updated to add a missing MODULE_DESCRIPTION()
macro.

* tag 'counter-updates-for-6.11' of ssh://gitolite.kernel.org/pub/scm/linux/kernel/git/wbg/counter:
  counter: ti-eqep: Allow eQEP driver to be built for K3 devices
  counter/ti-eqep: Add new ti-am62-eqep compatible
  dt-bindings: counter: Add new ti,am62-eqep compatible
  counter: ti-eqep: remove counter_priv() wrapper
  counter: ti-eqep: remove unused struct member
  counter: ti-eqep: implement over/underflow events
  counter: ftm-quaddec: add missing MODULE_DESCRIPTION() macro
parents f6663a96 988609f2

Documentation/devicetree/bindings/counter/ti-eqep.yaml

+22 −5
Original line number Diff line number Diff line
@@ -11,7 +11,9 @@ maintainers: 


properties:

  compatible:

    const: ti,am3352-eqep

    enum:

      - ti,am3352-eqep

      - ti,am62-eqep



  reg:

    maxItems: 1
@@ -21,19 +23,35 @@ properties: 
    maxItems: 1



  clocks:

    description: The clock that determines the SYSCLKOUT rate for the eQEP

      peripheral.

    description: The functional and interface clock that determines the clock

      rate for the eQEP peripheral.

    maxItems: 1



  clock-names:

    const: sysclkout



  power-domains:

    maxItems: 1



allOf:

  - if:

      properties:

        compatible:

          contains:

            enum:

              - ti,am62-eqep

    then:

      properties:

        clock-names: false



      required:

        - power-domains



required:

  - compatible

  - reg

  - interrupts

  - clocks

  - clock-names



additionalProperties: false
@@ -43,7 +61,6 @@ examples: 
        compatible = "ti,am3352-eqep";

        reg = <0x180 0x80>;

        clocks = <&l4ls_gclk>;

        clock-names = "sysclkout";

        interrupts = <79>;

    };

drivers/counter/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -138,7 +138,7 @@ config TI_ECAP_CAPTURE 


config TI_EQEP

	tristate "TI eQEP counter driver"

	depends on (SOC_AM33XX || COMPILE_TEST)

	depends on SOC_AM33XX || ARCH_K3 || COMPILE_TEST

	select REGMAP_MMIO

	help

	  Select this option to enable the Texas Instruments Enhanced Quadrature

drivers/counter/ftm-quaddec.c

+1 −0
Original line number Diff line number Diff line
@@ -322,6 +322,7 @@ static struct platform_driver ftm_quaddec_driver = { 


module_platform_driver(ftm_quaddec_driver);



MODULE_DESCRIPTION("Flex Timer Module Quadrature decoder");

MODULE_LICENSE("GPL");

MODULE_AUTHOR("Kjeld Flarup <kfa@deif.com>");

MODULE_AUTHOR("Patrick Havelange <patrick.havelange@essensium.com>");

drivers/counter/ti-eqep.c

+115 −16
Original line number Diff line number Diff line
@@ -8,6 +8,7 @@ 
#include <linux/bitops.h>

#include <linux/clk.h>

#include <linux/counter.h>

#include <linux/interrupt.h>

#include <linux/kernel.h>

#include <linux/mod_devicetable.h>

#include <linux/module.h>
@@ -68,6 +69,44 @@ 
#define QEPCTL_UTE		BIT(1)

#define QEPCTL_WDE		BIT(0)



#define QEINT_UTO		BIT(11)

#define QEINT_IEL		BIT(10)

#define QEINT_SEL		BIT(9)

#define QEINT_PCM		BIT(8)

#define QEINT_PCR		BIT(7)

#define QEINT_PCO		BIT(6)

#define QEINT_PCU		BIT(5)

#define QEINT_WTO		BIT(4)

#define QEINT_QDC		BIT(3)

#define QEINT_PHE		BIT(2)

#define QEINT_PCE		BIT(1)



#define QFLG_UTO		BIT(11)

#define QFLG_IEL		BIT(10)

#define QFLG_SEL		BIT(9)

#define QFLG_PCM		BIT(8)

#define QFLG_PCR		BIT(7)

#define QFLG_PCO		BIT(6)

#define QFLG_PCU		BIT(5)

#define QFLG_WTO		BIT(4)

#define QFLG_QDC		BIT(3)

#define QFLG_PHE		BIT(2)

#define QFLG_PCE		BIT(1)

#define QFLG_INT		BIT(0)



#define QCLR_UTO		BIT(11)

#define QCLR_IEL		BIT(10)

#define QCLR_SEL		BIT(9)

#define QCLR_PCM		BIT(8)

#define QCLR_PCR		BIT(7)

#define QCLR_PCO		BIT(6)

#define QCLR_PCU		BIT(5)

#define QCLR_WTO		BIT(4)

#define QCLR_QDC		BIT(3)

#define QCLR_PHE		BIT(2)

#define QCLR_PCE		BIT(1)

#define QCLR_INT		BIT(0)



/* EQEP Inputs */

enum {

	TI_EQEP_SIGNAL_QEPA,	/* QEPA/XCLK */
@@ -83,20 +122,14 @@ enum ti_eqep_count_func { 
};



struct ti_eqep_cnt {

	struct counter_device counter;

	struct regmap *regmap32;

	struct regmap *regmap16;

};



static struct ti_eqep_cnt *ti_eqep_count_from_counter(struct counter_device *counter)

{

	return counter_priv(counter);

}



static int ti_eqep_count_read(struct counter_device *counter,

			      struct counter_count *count, u64 *val)

{

	struct ti_eqep_cnt *priv = ti_eqep_count_from_counter(counter);

	struct ti_eqep_cnt *priv = counter_priv(counter);

	u32 cnt;



	regmap_read(priv->regmap32, QPOSCNT, &cnt);
@@ -108,7 +141,7 @@ static int ti_eqep_count_read(struct counter_device *counter, 
static int ti_eqep_count_write(struct counter_device *counter,

			       struct counter_count *count, u64 val)

{

	struct ti_eqep_cnt *priv = ti_eqep_count_from_counter(counter);

	struct ti_eqep_cnt *priv = counter_priv(counter);

	u32 max;



	regmap_read(priv->regmap32, QPOSMAX, &max);
@@ -122,7 +155,7 @@ static int ti_eqep_function_read(struct counter_device *counter, 
				 struct counter_count *count,

				 enum counter_function *function)

{

	struct ti_eqep_cnt *priv = ti_eqep_count_from_counter(counter);

	struct ti_eqep_cnt *priv = counter_priv(counter);

	u32 qdecctl;



	regmap_read(priv->regmap16, QDECCTL, &qdecctl);
@@ -149,7 +182,7 @@ static int ti_eqep_function_write(struct counter_device *counter, 
				  struct counter_count *count,

				  enum counter_function function)

{

	struct ti_eqep_cnt *priv = ti_eqep_count_from_counter(counter);

	struct ti_eqep_cnt *priv = counter_priv(counter);

	enum ti_eqep_count_func qsrc;



	switch (function) {
@@ -179,7 +212,7 @@ static int ti_eqep_action_read(struct counter_device *counter, 
			       struct counter_synapse *synapse,

			       enum counter_synapse_action *action)

{

	struct ti_eqep_cnt *priv = ti_eqep_count_from_counter(counter);

	struct ti_eqep_cnt *priv = counter_priv(counter);

	enum counter_function function;

	u32 qdecctl;

	int err;
@@ -239,19 +272,56 @@ static int ti_eqep_action_read(struct counter_device *counter, 
	}

}



static int ti_eqep_events_configure(struct counter_device *counter)

{

	struct ti_eqep_cnt *priv = counter_priv(counter);

	struct counter_event_node *event_node;

	u32 qeint = 0;



	list_for_each_entry(event_node, &counter->events_list, l) {

		switch (event_node->event) {

		case COUNTER_EVENT_OVERFLOW:

			qeint |= QEINT_PCO;

			break;

		case COUNTER_EVENT_UNDERFLOW:

			qeint |= QEINT_PCU;

			break;

		}

	}



	return regmap_write(priv->regmap16, QEINT, qeint);

}



static int ti_eqep_watch_validate(struct counter_device *counter,

				  const struct counter_watch *watch)

{

	switch (watch->event) {

	case COUNTER_EVENT_OVERFLOW:

	case COUNTER_EVENT_UNDERFLOW:

		if (watch->channel != 0)

			return -EINVAL;



		return 0;

	default:

		return -EINVAL;

	}

}



static const struct counter_ops ti_eqep_counter_ops = {

	.count_read	= ti_eqep_count_read,

	.count_write	= ti_eqep_count_write,

	.function_read	= ti_eqep_function_read,

	.function_write	= ti_eqep_function_write,

	.action_read	= ti_eqep_action_read,

	.events_configure = ti_eqep_events_configure,

	.watch_validate	= ti_eqep_watch_validate,

};



static int ti_eqep_position_ceiling_read(struct counter_device *counter,

					 struct counter_count *count,

					 u64 *ceiling)

{

	struct ti_eqep_cnt *priv = ti_eqep_count_from_counter(counter);

	struct ti_eqep_cnt *priv = counter_priv(counter);

	u32 qposmax;



	regmap_read(priv->regmap32, QPOSMAX, &qposmax);
@@ -265,7 +335,7 @@ static int ti_eqep_position_ceiling_write(struct counter_device *counter, 
					  struct counter_count *count,

					  u64 ceiling)

{

	struct ti_eqep_cnt *priv = ti_eqep_count_from_counter(counter);

	struct ti_eqep_cnt *priv = counter_priv(counter);



	if (ceiling != (u32)ceiling)

		return -ERANGE;
@@ -278,7 +348,7 @@ static int ti_eqep_position_ceiling_write(struct counter_device *counter, 
static int ti_eqep_position_enable_read(struct counter_device *counter,

					struct counter_count *count, u8 *enable)

{

	struct ti_eqep_cnt *priv = ti_eqep_count_from_counter(counter);

	struct ti_eqep_cnt *priv = counter_priv(counter);

	u32 qepctl;



	regmap_read(priv->regmap16, QEPCTL, &qepctl);
@@ -291,7 +361,7 @@ static int ti_eqep_position_enable_read(struct counter_device *counter, 
static int ti_eqep_position_enable_write(struct counter_device *counter,

					 struct counter_count *count, u8 enable)

{

	struct ti_eqep_cnt *priv = ti_eqep_count_from_counter(counter);

	struct ti_eqep_cnt *priv = counter_priv(counter);



	regmap_write_bits(priv->regmap16, QEPCTL, QEPCTL_PHEN, enable ? -1 : 0);
@@ -355,6 +425,25 @@ static struct counter_count ti_eqep_counts[] = { 
	},

};



static irqreturn_t ti_eqep_irq_handler(int irq, void *dev_id)

{

	struct counter_device *counter = dev_id;

	struct ti_eqep_cnt *priv = counter_priv(counter);

	u32 qflg;



	regmap_read(priv->regmap16, QFLG, &qflg);



	if (qflg & QFLG_PCO)

		counter_push_event(counter, COUNTER_EVENT_OVERFLOW, 0);



	if (qflg & QFLG_PCU)

		counter_push_event(counter, COUNTER_EVENT_UNDERFLOW, 0);



	regmap_write(priv->regmap16, QCLR, qflg);



	return IRQ_HANDLED;

}



static const struct regmap_config ti_eqep_regmap32_config = {

	.name = "32-bit",

	.reg_bits = 32,
@@ -378,7 +467,7 @@ static int ti_eqep_probe(struct platform_device *pdev) 
	struct ti_eqep_cnt *priv;

	void __iomem *base;

	struct clk *clk;

	int err;

	int err, irq;



	counter = devm_counter_alloc(dev, sizeof(*priv));

	if (!counter)
@@ -399,6 +488,15 @@ static int ti_eqep_probe(struct platform_device *pdev) 
	if (IS_ERR(priv->regmap16))

		return PTR_ERR(priv->regmap16);



	irq = platform_get_irq(pdev, 0);

	if (irq < 0)

		return irq;



	err = devm_request_threaded_irq(dev, irq, NULL, ti_eqep_irq_handler,

					IRQF_ONESHOT, dev_name(dev), counter);

	if (err < 0)

		return dev_err_probe(dev, err, "failed to request IRQ\n");



	counter->name = dev_name(dev);

	counter->parent = dev;

	counter->ops = &ti_eqep_counter_ops;
@@ -443,6 +541,7 @@ static void ti_eqep_remove(struct platform_device *pdev) 


static const struct of_device_id ti_eqep_of_match[] = {

	{ .compatible = "ti,am3352-eqep", },

	{ .compatible = "ti,am62-eqep", },

	{ },

};

MODULE_DEVICE_TABLE(of, ti_eqep_of_match);