usb: typec: ucsi: simplify command sending API

The sync_write and async_write are used only for writing UCSI commands
to the UCSI_CONTROL offsets. Rename sync_write and async_write
operations to sync_control and async_control accordingly. Drop the
offset and length fields and pass u64 command instead.

Tested-by: Heikki Krogerus <heikki.krogerus@linux.intel.com>
Reviewed-by: Heikki Krogerus <heikki.krogerus@linux.intel.com>
Signed-off-by: Dmitry Baryshkov <dmitry.baryshkov@linaro.org>
Link: https://lore.kernel.org/r/20240627-ucsi-rework-interface-v4-2-289ddc6874c7@linaro.org
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/usb/typec/ucsi/ucsi.c b/drivers/usb/typec/ucsi/ucsi.c
index 651c22473472943569a98f811e9f94ed921bf6f7..e8172b7711c87a74c664fb1880cb9ea5166c9f49 100644 (file)
--- a/drivers/usb/typec/ucsi/ucsi.c
+++ b/drivers/usb/typec/ucsi/ucsi.c
@@ -60,7 +60,7 @@ static int ucsi_acknowledge(struct ucsi *ucsi, bool conn_ack)
                ctrl |= UCSI_ACK_CONNECTOR_CHANGE;
        }
 
-       return ucsi->ops->sync_write(ucsi, UCSI_CONTROL, &ctrl, sizeof(ctrl));
+       return ucsi->ops->sync_control(ucsi, ctrl);
 }
 
 static int ucsi_exec_command(struct ucsi *ucsi, u64 command);
@@ -155,7 +155,7 @@ static int ucsi_exec_command(struct ucsi *ucsi, u64 cmd)
                connector_num = 0;
        }
 
-       ret = ucsi->ops->sync_write(ucsi, UCSI_CONTROL, &cmd, sizeof(cmd));
+       ret = ucsi->ops->sync_control(ucsi, cmd);
        if (ret)
                return ret;
 
@@ -1350,8 +1350,7 @@ static int ucsi_reset_ppm(struct ucsi *ucsi)
         */
        if (cci & UCSI_CCI_RESET_COMPLETE) {
                command = UCSI_SET_NOTIFICATION_ENABLE;
-               ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL, &command,
-                                            sizeof(command));
+               ret = ucsi->ops->async_control(ucsi, command);
                if (ret < 0)
                        goto out;
 
@@ -1372,8 +1371,7 @@ static int ucsi_reset_ppm(struct ucsi *ucsi)
        }
 
        command = UCSI_PPM_RESET;
-       ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL, &command,
-                                    sizeof(command));
+       ret = ucsi->ops->async_control(ucsi, command);
        if (ret < 0)
                goto out;
 
@@ -1394,9 +1392,7 @@ static int ucsi_reset_ppm(struct ucsi *ucsi)
 
                /* If the PPM is still doing something else, reset it again. */
                if (cci & ~UCSI_CCI_RESET_COMPLETE) {
-                       ret = ucsi->ops->async_write(ucsi, UCSI_CONTROL,
-                                                    &command,
-                                                    sizeof(command));
+                       ret = ucsi->ops->async_control(ucsi, command);
                        if (ret < 0)
                                goto out;
                }
@@ -1924,7 +1920,7 @@ struct ucsi *ucsi_create(struct device *dev, const struct ucsi_operations *ops)
 {
        struct ucsi *ucsi;
 
-       if (!ops || !ops->read || !ops->sync_write || !ops->async_write)
+       if (!ops || !ops->read || !ops->sync_control || !ops->async_control)
                return ERR_PTR(-EINVAL);
 
        ucsi = kzalloc(sizeof(*ucsi), GFP_KERNEL);
@@ -2000,7 +1996,7 @@ void ucsi_unregister(struct ucsi *ucsi)
        cancel_work_sync(&ucsi->resume_work);
 
        /* Disable notifications */
-       ucsi->ops->async_write(ucsi, UCSI_CONTROL, &cmd, sizeof(cmd));
+       ucsi->ops->async_control(ucsi, cmd);
 
        if (!ucsi->connector)
                return;

diff --git a/drivers/usb/typec/ucsi/ucsi.h b/drivers/usb/typec/ucsi/ucsi.h
index fe95a80050d314c19735aa1b69de7e9a7905e673..a8c161a39f118e859999e99124a77d8a86d56652 100644 (file)
--- a/drivers/usb/typec/ucsi/ucsi.h
+++ b/drivers/usb/typec/ucsi/ucsi.h
@@ -57,8 +57,8 @@ struct dentry;
 /**
  * struct ucsi_operations - UCSI I/O operations
  * @read: Read operation
- * @sync_write: Blocking write operation
- * @async_write: Non-blocking write operation
+ * @sync_control: Blocking control operation
+ * @async_control: Non-blocking control operation
  * @update_altmodes: Squashes duplicate DP altmodes
  * @update_connector: Update connector capabilities before registering
  * @connector_status: Updates connector status, called holding connector lock
@@ -70,10 +70,8 @@ struct dentry;
 struct ucsi_operations {
        int (*read)(struct ucsi *ucsi, unsigned int offset,
                    void *val, size_t val_len);
-       int (*sync_write)(struct ucsi *ucsi, unsigned int offset,
-                         const void *val, size_t val_len);
-       int (*async_write)(struct ucsi *ucsi, unsigned int offset,
-                          const void *val, size_t val_len);
+       int (*sync_control)(struct ucsi *ucsi, u64 command);
+       int (*async_control)(struct ucsi *ucsi, u64 command);
        bool (*update_altmodes)(struct ucsi *ucsi, struct ucsi_altmode *orig,
                                struct ucsi_altmode *updated);
        void (*update_connector)(struct ucsi_connector *con);

diff --git a/drivers/usb/typec/ucsi/ucsi_acpi.c b/drivers/usb/typec/ucsi/ucsi_acpi.c
index adf32ca0f761b214215fe55b3176336e8180cf22..f54e4722d8f6ffe088893188a89e128857f3371e 100644 (file)
--- a/drivers/usb/typec/ucsi/ucsi_acpi.c
+++ b/drivers/usb/typec/ucsi/ucsi_acpi.c
@@ -61,22 +61,20 @@ static int ucsi_acpi_read(struct ucsi *ucsi, unsigned int offset,
        return 0;
 }
 
-static int ucsi_acpi_async_write(struct ucsi *ucsi, unsigned int offset,
-                                const void *val, size_t val_len)
+static int ucsi_acpi_async_control(struct ucsi *ucsi, u64 command)
 {
        struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi);
 
-       memcpy(ua->base + offset, val, val_len);
-       ua->cmd = *(u64 *)val;
+       memcpy(ua->base + UCSI_CONTROL, &command, sizeof(command));
+       ua->cmd = command;
 
        return ucsi_acpi_dsm(ua, UCSI_DSM_FUNC_WRITE);
 }
 
-static int ucsi_acpi_sync_write(struct ucsi *ucsi, unsigned int offset,
-                               const void *val, size_t val_len)
+static int ucsi_acpi_sync_control(struct ucsi *ucsi, u64 command)
 {
        struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi);
-       bool ack = UCSI_COMMAND(*(u64 *)val) == UCSI_ACK_CC_CI;
+       bool ack = UCSI_COMMAND(command) == UCSI_ACK_CC_CI;
        int ret;
 
        if (ack)
@@ -84,7 +82,7 @@ static int ucsi_acpi_sync_write(struct ucsi *ucsi, unsigned int offset,
        else
                set_bit(UCSI_ACPI_COMMAND_PENDING, &ua->flags);
 
-       ret = ucsi_acpi_async_write(ucsi, offset, val, val_len);
+       ret = ucsi_acpi_async_control(ucsi, command);
        if (ret)
                goto out_clear_bit;
 
@@ -102,8 +100,8 @@ out_clear_bit:
 
 static const struct ucsi_operations ucsi_acpi_ops = {
        .read = ucsi_acpi_read,
-       .sync_write = ucsi_acpi_sync_write,
-       .async_write = ucsi_acpi_async_write
+       .sync_control = ucsi_acpi_sync_control,
+       .async_control = ucsi_acpi_async_control
 };
 
 static int
@@ -125,8 +123,8 @@ ucsi_zenbook_read(struct ucsi *ucsi, unsigned int offset, void *val, size_t val_
 
 static const struct ucsi_operations ucsi_zenbook_ops = {
        .read = ucsi_zenbook_read,
-       .sync_write = ucsi_acpi_sync_write,
-       .async_write = ucsi_acpi_async_write
+       .sync_control = ucsi_acpi_sync_control,
+       .async_control = ucsi_acpi_async_control
 };
 
 static int ucsi_gram_read(struct ucsi *ucsi, unsigned int offset,
@@ -157,13 +155,12 @@ static int ucsi_gram_read(struct ucsi *ucsi, unsigned int offset,
        return ret;
 }
 
-static int ucsi_gram_sync_write(struct ucsi *ucsi, unsigned int offset,
-                               const void *val, size_t val_len)
+static int ucsi_gram_sync_control(struct ucsi *ucsi, u64 command)
 {
        struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi);
        int ret;
 
-       ret = ucsi_acpi_sync_write(ucsi, offset, val, val_len);
+       ret = ucsi_acpi_sync_control(ucsi, command);
        if (ret < 0)
                return ret;
 
@@ -177,8 +174,8 @@ static int ucsi_gram_sync_write(struct ucsi *ucsi, unsigned int offset,
 
 static const struct ucsi_operations ucsi_gram_ops = {
        .read = ucsi_gram_read,
-       .sync_write = ucsi_gram_sync_write,
-       .async_write = ucsi_acpi_async_write
+       .sync_control = ucsi_gram_sync_control,
+       .async_control = ucsi_acpi_async_control
 };
 
 static const struct dmi_system_id ucsi_acpi_quirks[] = {

diff --git a/drivers/usb/typec/ucsi/ucsi_ccg.c b/drivers/usb/typec/ucsi/ucsi_ccg.c
index dda7c7c94e08a95a37059574206448bb77820d90..76b39bb9762d1a0c590ed86e65b6c61cd3e8e890 100644 (file)
--- a/drivers/usb/typec/ucsi/ucsi_ccg.c
+++ b/drivers/usb/typec/ucsi/ucsi_ccg.c
@@ -610,25 +610,23 @@ static int ucsi_ccg_read(struct ucsi *ucsi, unsigned int offset,
        return ret;
 }
 
-static int ucsi_ccg_async_write(struct ucsi *ucsi, unsigned int offset,
-                               const void *val, size_t val_len)
+static int ucsi_ccg_async_control(struct ucsi *ucsi, u64 command)
 {
        struct ucsi_ccg *uc = ucsi_get_drvdata(ucsi);
-       u16 reg = CCGX_RAB_UCSI_DATA_BLOCK(offset);
+       u16 reg = CCGX_RAB_UCSI_DATA_BLOCK(UCSI_CONTROL);
 
        /*
-        * UCSI may read CCI instantly after async_write,
+        * UCSI may read CCI instantly after async_control,
         * clear CCI to avoid caller getting wrong data before we get CCI from ISR
         */
        spin_lock(&uc->op_lock);
        uc->op_data.cci = 0;
        spin_unlock(&uc->op_lock);
 
-       return ccg_write(uc, reg, val, val_len);
+       return ccg_write(uc, reg, (u8 *)&command, sizeof(command));
 }
 
-static int ucsi_ccg_sync_write(struct ucsi *ucsi, unsigned int offset,
-                              const void *val, size_t val_len)
+static int ucsi_ccg_sync_control(struct ucsi *ucsi, u64 command)
 {
        struct ucsi_ccg *uc = ucsi_get_drvdata(ucsi);
        struct ucsi_connector *con;
@@ -639,19 +637,17 @@ static int ucsi_ccg_sync_write(struct ucsi *ucsi, unsigned int offset,
        pm_runtime_get_sync(uc->dev);
        set_bit(DEV_CMD_PENDING, &uc->flags);
 
-       if (offset == UCSI_CONTROL && val_len == sizeof(uc->last_cmd_sent)) {
-               uc->last_cmd_sent = *(u64 *)val;
+       uc->last_cmd_sent = command;
 
-               if (UCSI_COMMAND(uc->last_cmd_sent) == UCSI_SET_NEW_CAM &&
-                   uc->has_multiple_dp) {
-                       con_index = (uc->last_cmd_sent >> 16) &
-                                   UCSI_CMD_CONNECTOR_MASK;
-                       con = &uc->ucsi->connector[con_index - 1];
-                       ucsi_ccg_update_set_new_cam_cmd(uc, con, (u64 *)val);
-               }
+       if (UCSI_COMMAND(uc->last_cmd_sent) == UCSI_SET_NEW_CAM &&
+           uc->has_multiple_dp) {
+               con_index = (uc->last_cmd_sent >> 16) &
+                       UCSI_CMD_CONNECTOR_MASK;
+               con = &uc->ucsi->connector[con_index - 1];
+               ucsi_ccg_update_set_new_cam_cmd(uc, con, &command);
        }
 
-       ret = ucsi_ccg_async_write(ucsi, offset, val, val_len);
+       ret = ucsi_ccg_async_control(ucsi, command);
        if (ret)
                goto err_clear_bit;
 
@@ -668,8 +664,8 @@ err_clear_bit:
 
 static const struct ucsi_operations ucsi_ccg_ops = {
        .read = ucsi_ccg_read,
-       .sync_write = ucsi_ccg_sync_write,
-       .async_write = ucsi_ccg_async_write,
+       .sync_control = ucsi_ccg_sync_control,
+       .async_control = ucsi_ccg_async_control,
        .update_altmodes = ucsi_ccg_update_altmodes
 };
 

diff --git a/drivers/usb/typec/ucsi/ucsi_glink.c b/drivers/usb/typec/ucsi/ucsi_glink.c
index 2fa973afe4e68bba24d895f748bbe5eed38f8278..ebd76257c4fcf8e889378b3af0e111bbac8a63dc 100644 (file)
--- a/drivers/usb/typec/ucsi/ucsi_glink.c
+++ b/drivers/usb/typec/ucsi/ucsi_glink.c
@@ -143,21 +143,19 @@ static int pmic_glink_ucsi_locked_write(struct pmic_glink_ucsi *ucsi, unsigned i
        return 0;
 }
 
-static int pmic_glink_ucsi_async_write(struct ucsi *__ucsi, unsigned int offset,
-                                      const void *val, size_t val_len)
+static int pmic_glink_ucsi_async_control(struct ucsi *__ucsi, u64 command)
 {
        struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi);
        int ret;
 
        mutex_lock(&ucsi->lock);
-       ret = pmic_glink_ucsi_locked_write(ucsi, offset, val, val_len);
+       ret = pmic_glink_ucsi_locked_write(ucsi, UCSI_CONTROL, &command, sizeof(command));
        mutex_unlock(&ucsi->lock);
 
        return ret;
 }
 
-static int pmic_glink_ucsi_sync_write(struct ucsi *__ucsi, unsigned int offset,
-                                     const void *val, size_t val_len)
+static int pmic_glink_ucsi_sync_control(struct ucsi *__ucsi, u64 command)
 {
        struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi);
        unsigned long left;
@@ -169,7 +167,7 @@ static int pmic_glink_ucsi_sync_write(struct ucsi *__ucsi, unsigned int offset,
        ucsi->sync_val = 0;
        reinit_completion(&ucsi->sync_ack);
        ucsi->sync_pending = true;
-       ret = pmic_glink_ucsi_locked_write(ucsi, offset, val, val_len);
+       ret = pmic_glink_ucsi_locked_write(ucsi, UCSI_CONTROL, &command, sizeof(command));
        mutex_unlock(&ucsi->lock);
 
        left = wait_for_completion_timeout(&ucsi->sync_ack, 5 * HZ);
@@ -217,8 +215,8 @@ static void pmic_glink_ucsi_connector_status(struct ucsi_connector *con)
 
 static const struct ucsi_operations pmic_glink_ucsi_ops = {
        .read = pmic_glink_ucsi_read,
-       .sync_write = pmic_glink_ucsi_sync_write,
-       .async_write = pmic_glink_ucsi_async_write,
+       .sync_control = pmic_glink_ucsi_sync_control,
+       .async_control = pmic_glink_ucsi_async_control,
        .update_connector = pmic_glink_ucsi_update_connector,
        .connector_status = pmic_glink_ucsi_connector_status,
 };

diff --git a/drivers/usb/typec/ucsi/ucsi_stm32g0.c b/drivers/usb/typec/ucsi/ucsi_stm32g0.c
index ac69288e8bb08fe5bb9ef64d35c0fcac4af50522..396e2090e7c36d10012a8e3cc9e1b634c62f20e7 100644 (file)
--- a/drivers/usb/typec/ucsi/ucsi_stm32g0.c
+++ b/drivers/usb/typec/ucsi/ucsi_stm32g0.c
@@ -359,8 +359,7 @@ static int ucsi_stm32g0_read(struct ucsi *ucsi, unsigned int offset, void *val,
        return 0;
 }
 
-static int ucsi_stm32g0_async_write(struct ucsi *ucsi, unsigned int offset, const void *val,
-                                   size_t len)
+static int ucsi_stm32g0_async_control(struct ucsi *ucsi, u64 command)
 {
        struct ucsi_stm32g0 *g0 = ucsi_get_drvdata(ucsi);
        struct i2c_client *client = g0->client;
@@ -373,19 +372,19 @@ static int ucsi_stm32g0_async_write(struct ucsi *ucsi, unsigned int offset, cons
        unsigned char *buf;
        int ret;
 
-       buf = kmalloc(len + 1, GFP_KERNEL);
+       buf = kmalloc(sizeof(command) + 1, GFP_KERNEL);
        if (!buf)
                return -ENOMEM;
 
-       buf[0] = offset;
-       memcpy(&buf[1], val, len);
-       msg[0].len = len + 1;
+       buf[0] = UCSI_CONTROL;
+       memcpy(&buf[1], &command, sizeof(command));
+       msg[0].len = sizeof(command) + 1;
        msg[0].buf = buf;
 
        ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
        kfree(buf);
        if (ret != ARRAY_SIZE(msg)) {
-               dev_err(g0->dev, "i2c write %02x, %02x error: %d\n", client->addr, offset, ret);
+               dev_err(g0->dev, "i2c write %02x, %02x error: %d\n", client->addr, UCSI_CONTROL, ret);
 
                return ret < 0 ? ret : -EIO;
        }
@@ -393,11 +392,10 @@ static int ucsi_stm32g0_async_write(struct ucsi *ucsi, unsigned int offset, cons
        return 0;
 }
 
-static int ucsi_stm32g0_sync_write(struct ucsi *ucsi, unsigned int offset, const void *val,
-                                  size_t len)
+static int ucsi_stm32g0_sync_control(struct ucsi *ucsi, u64 command)
 {
        struct ucsi_stm32g0 *g0 = ucsi_get_drvdata(ucsi);
-       bool ack = UCSI_COMMAND(*(u64 *)val) == UCSI_ACK_CC_CI;
+       bool ack = UCSI_COMMAND(command) == UCSI_ACK_CC_CI;
        int ret;
 
        if (ack)
@@ -405,7 +403,7 @@ static int ucsi_stm32g0_sync_write(struct ucsi *ucsi, unsigned int offset, const
        else
                set_bit(COMMAND_PENDING, &g0->flags);
 
-       ret = ucsi_stm32g0_async_write(ucsi, offset, val, len);
+       ret = ucsi_stm32g0_async_control(ucsi, command);
        if (ret)
                goto out_clear_bit;
 
@@ -449,8 +447,8 @@ static irqreturn_t ucsi_stm32g0_irq_handler(int irq, void *data)
 
 static const struct ucsi_operations ucsi_stm32g0_ops = {
        .read = ucsi_stm32g0_read,
-       .sync_write = ucsi_stm32g0_sync_write,
-       .async_write = ucsi_stm32g0_async_write,
+       .sync_control = ucsi_stm32g0_sync_control,
+       .async_control = ucsi_stm32g0_async_control,
 };
 
 static int ucsi_stm32g0_register(struct ucsi *ucsi)

diff --git a/drivers/usb/typec/ucsi/ucsi_yoga_c630.c b/drivers/usb/typec/ucsi/ucsi_yoga_c630.c
index 8bee0b46904119f8dc9d91619920a7fdbb799abd..e5e8ba0c0eaa7d5410cc29062b34428b497b4d96 100644 (file)
--- a/drivers/usb/typec/ucsi/ucsi_yoga_c630.c
+++ b/drivers/usb/typec/ucsi/ucsi_yoga_c630.c
@@ -56,23 +56,17 @@ static int yoga_c630_ucsi_read(struct ucsi *ucsi, unsigned int offset,
        }
 }
 
-static int yoga_c630_ucsi_async_write(struct ucsi *ucsi, unsigned int offset,
-                                     const void *val, size_t val_len)
+static int yoga_c630_ucsi_async_control(struct ucsi *ucsi, u64 command)
 {
        struct yoga_c630_ucsi *uec = ucsi_get_drvdata(ucsi);
 
-       if (offset != UCSI_CONTROL ||
-           val_len != YOGA_C630_UCSI_WRITE_SIZE)
-               return -EINVAL;
-
-       return yoga_c630_ec_ucsi_write(uec->ec, val);
+       return yoga_c630_ec_ucsi_write(uec->ec, (u8*)&command);
 }
 
-static int yoga_c630_ucsi_sync_write(struct ucsi *ucsi, unsigned int offset,
-                                    const void *val, size_t val_len)
+static int yoga_c630_ucsi_sync_control(struct ucsi *ucsi, u64 command)
 {
        struct yoga_c630_ucsi *uec = ucsi_get_drvdata(ucsi);
-       bool ack = UCSI_COMMAND(*(u64 *)val) == UCSI_ACK_CC_CI;
+       bool ack = UCSI_COMMAND(command) == UCSI_ACK_CC_CI;
        int ret;
 
        if (ack)
@@ -82,7 +76,7 @@ static int yoga_c630_ucsi_sync_write(struct ucsi *ucsi, unsigned int offset,
 
        reinit_completion(&uec->complete);
 
-       ret = yoga_c630_ucsi_async_write(ucsi, offset, val, val_len);
+       ret = yoga_c630_ucsi_async_control(ucsi, command);
        if (ret)
                goto out_clear_bit;
 
@@ -100,8 +94,8 @@ out_clear_bit:
 
 const struct ucsi_operations yoga_c630_ucsi_ops = {
        .read = yoga_c630_ucsi_read,
-       .sync_write = yoga_c630_ucsi_sync_write,
-       .async_write = yoga_c630_ucsi_async_write,
+       .sync_control = yoga_c630_ucsi_sync_control,
+       .async_control = yoga_c630_ucsi_async_control,
 };
 
 static void yoga_c630_ucsi_notify_ucsi(struct yoga_c630_ucsi *uec, u32 cci)