[PATCH v6 08/14] USB: typec: Add interrupt support for TPS25750

Abdel Alkuor
2023-09-23T07:41:13Z

tps25750 event registers structure is different than tps6598x's,
tps25750 has 11 bytes of events which are read at once where
tps6598x has two event registers of 8 bytes each which are read
separately. Likewise MASK event registers. Also, not all events
are supported in both devices.

Update tps6598x interrupt handler to accommodate tps25750 interrupt

Signed-off-by: Abdel Alkuor <abdelalkuor@geotab.com>
---
Changes in v6:
- Create tipd callbacks factory
Changes in v5:
- Incorporating tps25750 into tps6598x driver

drivers/usb/typec/tipd/core.c | 102 +++++++++++++++++++++++++++-------
1 file changed, 83 insertions(+), 19 deletions(-)

diff --git a/drivers/usb/typec/tipd/core.c b/drivers/usb/typec/tipd/core.c
index 56ffffe225f2..cde52afe5097 100644
--- a/drivers/usb/typec/tipd/core.c
+++ b/drivers/usb/typec/tipd/core.c
@@ -101,6 +101,14 @@ static const char *const modes[] = {
/* Unrecognized commands will be replaced with "!CMD" */
#define INVALID_CMD(_cmd_) (_cmd_ == 0x444d4321)

+struct tps6598x;
+
+struct tipd_data {
+ irq_handler_t irq_handler;
+ int (*read_events)(struct tps6598x *tps, void *events);
+ int (*clear_events)(struct tps6598x *tps, void *events);
+};
+
struct tps6598x {
struct device *dev;
struct regmap *regmap;
@@ -118,9 +126,11 @@ struct tps6598x {
enum power_supply_usb_type usb_type;

int wakeup;
+ u32 status; /* status reg */
u16 pwr_status;
struct delayed_work wq_poll;
- irq_handler_t irq_handler;
+
+ struct tipd_data cb;
};

static enum power_supply_property tps6598x_psy_props[] = {
@@ -500,6 +510,32 @@ static void tps6598x_handle_plug_event(struct tps6598x *tps, u32 status)
}
}

+static int tps6598x_read_events(struct tps6598x *tps, void *events)
+{
+ uint64_t *e = events;
+
+ return tps6598x_read64(tps, TPS_REG_INT_EVENT1, &e[0]) |
+ tps6598x_read64(tps, TPS_REG_INT_EVENT2, &e[1]);
+}
+
+static int tps6598x_clear_events(struct tps6598x *tps, void *events)
+{
+ uint64_t *e = events;
+
+ return tps6598x_write64(tps, TPS_REG_INT_CLEAR1, e[0]) |
+ tps6598x_write64(tps, TPS_REG_INT_CLEAR2, e[1]);
+}
+
+static int tps25750_read_events(struct tps6598x *tps, void *events)
+{
+ return tps6598x_block_read(tps, TPS_REG_INT_EVENT1, events, 11);
+}
+
+static int tps25750_clear_events(struct tps6598x *tps, void *events)
+{
+ return tps6598x_block_write(tps, TPS_REG_INT_CLEAR1, events, 11);
+}
+
static irqreturn_t cd321x_interrupt(int irq, void *data)
{
struct tps6598x *tps = data;
@@ -545,50 +581,60 @@ static irqreturn_t cd321x_interrupt(int irq, void *data)
return IRQ_NONE;
}

+static bool tps6598x_has_role_changed(struct tps6598x *tps, u32 status)
+{
+ status ^= tps->status;
+
+ return status & (TPS_STATUS_PORTROLE | TPS_STATUS_DATAROLE);
+}
+
static irqreturn_t tps6598x_interrupt(int irq, void *data)
{
struct tps6598x *tps = data;
- u64 event1 = 0;
- u64 event2 = 0;
+ u64 event[2] = { };
u32 status;
int ret;

mutex_lock(&tps->lock);

- ret = tps6598x_read64(tps, TPS_REG_INT_EVENT1, &event1);
- ret |= tps6598x_read64(tps, TPS_REG_INT_EVENT2, &event2);
+ ret = tps->cb.read_events(tps, event);
if (ret) {
dev_err(tps->dev, "%s: failed to read events\n", __func__);
goto err_unlock;
}
- trace_tps6598x_irq(event1, event2);
+ trace_tps6598x_irq(event[0], event[1]);

- if (!(event1 | event2))
+ if (!(event[0] | event[1]))
goto err_unlock;

if (!tps6598x_read_status(tps, &status))
goto err_clear_ints;

- if ((event1 | event2) & TPS_REG_INT_POWER_STATUS_UPDATE)
+ if ((event[0] | event[1]) & TPS_REG_INT_POWER_STATUS_UPDATE)
if (!tps6598x_read_power_status(tps))
goto err_clear_ints;

- if ((event1 | event2) & TPS_REG_INT_DATA_STATUS_UPDATE)
+ if ((event[0] | event[1]) & TPS_REG_INT_DATA_STATUS_UPDATE)
if (!tps6598x_read_data_status(tps))
goto err_clear_ints;

- /* Handle plug insert or removal */
- if ((event1 | event2) & TPS_REG_INT_PLUG_EVENT)
+ /*
+ * data/port roles could be updated independently after
+ * a plug event. Therefore, we need to check
+ * for pr/dr status change to set TypeC dr/pr accordingly.
+ */
+ if ((event[0] | event[1]) & TPS_REG_INT_PLUG_EVENT ||
+ tps6598x_has_role_changed(tps, status))
tps6598x_handle_plug_event(tps, status);

+ tps->status = status;
err_clear_ints:
- tps6598x_write64(tps, TPS_REG_INT_CLEAR1, event1);
- tps6598x_write64(tps, TPS_REG_INT_CLEAR2, event2);
+ tps->cb.clear_events(tps, event);

err_unlock:
mutex_unlock(&tps->lock);

- if (event1 | event2)
+ if (event[0] | event[1])
return IRQ_HANDLED;
return IRQ_NONE;
}
@@ -600,7 +646,7 @@ static void tps6598x_poll_work(struct work_struct *work)
struct tps6598x *tps = container_of(to_delayed_work(work),
struct tps6598x, wq_poll);

- tps->irq_handler(0, tps);
+ tps->cb.irq_handler(0, tps);
queue_delayed_work(system_power_efficient_wq,
&tps->wq_poll, msecs_to_jiffies(POLL_INTERVAL));
}
@@ -967,9 +1013,24 @@ static int tps25750_apply_patch(struct tps6598x *tps)
return 0;
};

+static const struct tipd_data cd321x_data = {
+ .irq_handler = cd321x_interrupt,
+};
+
+static const struct tipd_data tps6598x_data = {
+ .irq_handler = tps6598x_interrupt,
+ .read_events = tps6598x_read_events,
+ .clear_events = tps6598x_clear_events,
+};
+
+static const struct tipd_data tps25750_data = {
+ .irq_handler = tps6598x_interrupt,
+ .read_events = tps25750_read_events,
+ .clear_events = tps25750_clear_events,
+};
+
static int tps6598x_probe(struct i2c_client *client)
{
- irq_handler_t irq_handler = tps6598x_interrupt;
struct device_node *np = client->dev.of_node;
struct typec_capability typec_cap = { };
struct tps6598x *tps;
@@ -1017,15 +1078,18 @@ static int tps6598x_probe(struct i2c_client *client)
APPLE_CD_REG_INT_DATA_STATUS_UPDATE |
APPLE_CD_REG_INT_PLUG_EVENT;

- irq_handler = cd321x_interrupt;
+ tps->cb = cd321x_data;
} else {
+ if (is_tps25750)
+ tps->cb = tps25750_data;
+ else
+ tps->cb = tps6598x_data;
/* Enable power status, data status and plug event interrupts */
mask1 = TPS_REG_INT_POWER_STATUS_UPDATE |
TPS_REG_INT_DATA_STATUS_UPDATE |
TPS_REG_INT_PLUG_EVENT;
}

- tps->irq_handler = irq_handler;
/* Make sure the controller has application firmware running */
ret = tps6598x_check_mode(tps);
if (ret < 0)
@@ -1125,7 +1189,7 @@ static int tps6598x_probe(struct i2c_client *client)

if (client->irq) {
ret = devm_request_threaded_irq(&client->dev, client->irq, NULL,
- irq_handler,
+ tps->cb.irq_handler,
IRQF_SHARED | IRQF_ONESHOT,
dev_name(&client->dev), tps);
} else {
--
2.34.1