drivers/usb/typec/ucsi/ucsi_glink.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
   4  * Copyright (c) 2023, Linaro Ltd
   5  */
   6 #include <linux/auxiliary_bus.h>
   7 #include <linux/module.h>
   8 #include <linux/of_device.h>
   9 #include <linux/mutex.h>
  10 #include <linux/property.h>
  11 #include <linux/soc/qcom/pdr.h>
  12 #include <linux/soc/qcom/pmic_glink.h>
  13 #include "ucsi.h"
  14
  15 #define UCSI_BUF_SIZE                   48
  16
  17 #define MSG_TYPE_REQ_RESP               1
  18 #define UCSI_BUF_SIZE                   48
  19
  20 #define UC_NOTIFY_RECEIVER_UCSI         0x0
  21 #define UC_UCSI_READ_BUF_REQ            0x11
  22 #define UC_UCSI_WRITE_BUF_REQ           0x12
  23 #define UC_UCSI_USBC_NOTIFY_IND         0x13
  24
  25 struct ucsi_read_buf_req_msg {
  26         struct pmic_glink_hdr   hdr;
  27 };
  28
  29 struct ucsi_read_buf_resp_msg {
  30         struct pmic_glink_hdr   hdr;
  31         u8                      buf[UCSI_BUF_SIZE];
  32         u32                     ret_code;
  33 };
  34
  35 struct ucsi_write_buf_req_msg {
  36         struct pmic_glink_hdr   hdr;
  37         u8                      buf[UCSI_BUF_SIZE];
  38         u32                     reserved;
  39 };
  40
  41 struct ucsi_write_buf_resp_msg {
  42         struct pmic_glink_hdr   hdr;
  43         u32                     ret_code;
  44 };
  45
  46 struct ucsi_notify_ind_msg {
  47         struct pmic_glink_hdr   hdr;
  48         u32                     notification;
  49         u32                     receiver;
  50         u32                     reserved;
  51 };
  52
  53 struct pmic_glink_ucsi {
  54         struct device *dev;
  55
  56         struct pmic_glink_client *client;
  57
  58         struct ucsi *ucsi;
  59         struct completion read_ack;
  60         struct completion write_ack;
  61         struct completion sync_ack;
  62         bool sync_pending;
  63         struct mutex lock;      /* protects concurrent access to PMIC Glink interface */
  64
  65         int sync_val;
  66
  67         struct work_struct notify_work;
  68         struct work_struct register_work;
  69
  70         u8 read_buf[UCSI_BUF_SIZE];
  71 };
  72
  73 static int pmic_glink_ucsi_read(struct ucsi *__ucsi, unsigned int offset,
  74                                 void *val, size_t val_len)
  75 {
  76         struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi);
  77         struct ucsi_read_buf_req_msg req = {};
  78         unsigned long left;
  79         int ret;
  80
  81         req.hdr.owner = PMIC_GLINK_OWNER_USBC;
  82         req.hdr.type = MSG_TYPE_REQ_RESP;
  83         req.hdr.opcode = UC_UCSI_READ_BUF_REQ;
  84
  85         mutex_lock(&ucsi->lock);
  86         memset(ucsi->read_buf, 0, sizeof(ucsi->read_buf));
  87         reinit_completion(&ucsi->read_ack);
  88
  89         ret = pmic_glink_send(ucsi->client, &req, sizeof(req));
  90         if (ret < 0) {
  91                 dev_err(ucsi->dev, "failed to send UCSI read request: %d\n", ret);
  92                 goto out_unlock;
  93         }
  94
  95         left = wait_for_completion_timeout(&ucsi->read_ack, 5 * HZ);
  96         if (!left) {
  97                 dev_err(ucsi->dev, "timeout waiting for UCSI read response\n");
  98                 ret = -ETIMEDOUT;
  99                 goto out_unlock;
 100         }
 101
 102         memcpy(val, &ucsi->read_buf[offset], val_len);
 103         ret = 0;
 104
 105 out_unlock:
 106         mutex_unlock(&ucsi->lock);
 107
 108         return ret;
 109 }
 110
 111 static int pmic_glink_ucsi_locked_write(struct pmic_glink_ucsi *ucsi, unsigned int offset,
 112                                         const void *val, size_t val_len)
 113 {
 114         struct ucsi_write_buf_req_msg req = {};
 115         unsigned long left;
 116         int ret;
 117
 118         req.hdr.owner = PMIC_GLINK_OWNER_USBC;
 119         req.hdr.type = MSG_TYPE_REQ_RESP;
 120         req.hdr.opcode = UC_UCSI_WRITE_BUF_REQ;
 121         memcpy(&req.buf[offset], val, val_len);
 122
 123         reinit_completion(&ucsi->write_ack);
 124
 125         ret = pmic_glink_send(ucsi->client, &req, sizeof(req));
 126         if (ret < 0) {
 127                 dev_err(ucsi->dev, "failed to send UCSI write request: %d\n", ret);
 128                 return ret;
 129         }
 130
 131         left = wait_for_completion_timeout(&ucsi->write_ack, 5 * HZ);
 132         if (!left) {
 133                 dev_err(ucsi->dev, "timeout waiting for UCSI write response\n");
 134                 return -ETIMEDOUT;
 135         }
 136
 137         return 0;
 138 }
 139
 140 static int pmic_glink_ucsi_async_write(struct ucsi *__ucsi, unsigned int offset,
 141                                        const void *val, size_t val_len)
 142 {
 143         struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi);
 144         int ret;
 145
 146         mutex_lock(&ucsi->lock);
 147         ret = pmic_glink_ucsi_locked_write(ucsi, offset, val, val_len);
 148         mutex_unlock(&ucsi->lock);
 149
 150         return ret;
 151 }
 152
 153 static int pmic_glink_ucsi_sync_write(struct ucsi *__ucsi, unsigned int offset,
 154                                       const void *val, size_t val_len)
 155 {
 156         struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi);
 157         unsigned long left;
 158         int ret;
 159
 160         /* TOFIX: Downstream forces recipient to CON when UCSI_GET_ALTERNATE_MODES command */
 161
 162         mutex_lock(&ucsi->lock);
 163         ucsi->sync_val = 0;
 164         reinit_completion(&ucsi->sync_ack);
 165         ucsi->sync_pending = true;
 166         ret = pmic_glink_ucsi_locked_write(ucsi, offset, val, val_len);
 167         mutex_unlock(&ucsi->lock);
 168
 169         left = wait_for_completion_timeout(&ucsi->sync_ack, 5 * HZ);
 170         if (!left) {
 171                 dev_err(ucsi->dev, "timeout waiting for UCSI sync write response\n");
 172                 ret = -ETIMEDOUT;
 173         } else if (ucsi->sync_val) {
 174                 dev_err(ucsi->dev, "sync write returned: %d\n", ucsi->sync_val);
 175         }
 176
 177         ucsi->sync_pending = false;
 178
 179         return ret;
 180 }
 181
 182 static const struct ucsi_operations pmic_glink_ucsi_ops = {
 183         .read = pmic_glink_ucsi_read,
 184         .sync_write = pmic_glink_ucsi_sync_write,
 185         .async_write = pmic_glink_ucsi_async_write
 186 };
 187
 188 static void pmic_glink_ucsi_read_ack(struct pmic_glink_ucsi *ucsi, const void *data, int len)
 189 {
 190         const struct ucsi_read_buf_resp_msg *resp = data;
 191
 192         if (resp->ret_code)
 193                 return;
 194
 195         memcpy(ucsi->read_buf, resp->buf, UCSI_BUF_SIZE);
 196         complete(&ucsi->read_ack);
 197 }
 198
 199 static void pmic_glink_ucsi_write_ack(struct pmic_glink_ucsi *ucsi, const void *data, int len)
 200 {
 201         const struct ucsi_write_buf_resp_msg *resp = data;
 202
 203         if (resp->ret_code)
 204                 return;
 205
 206         ucsi->sync_val = resp->ret_code;
 207         complete(&ucsi->write_ack);
 208 }
 209
 210 static void pmic_glink_ucsi_notify(struct work_struct *work)
 211 {
 212         struct pmic_glink_ucsi *ucsi = container_of(work, struct pmic_glink_ucsi, notify_work);
 213         unsigned int con_num;
 214         u32 cci;
 215         int ret;
 216
 217         ret = pmic_glink_ucsi_read(ucsi->ucsi, UCSI_CCI, &cci, sizeof(cci));
 218         if (ret) {
 219                 dev_err(ucsi->dev, "failed to read CCI on notification\n");
 220                 return;
 221         }
 222
 223         con_num = UCSI_CCI_CONNECTOR(cci);
 224         if (con_num)
 225                 ucsi_connector_change(ucsi->ucsi, con_num);
 226
 227         if (ucsi->sync_pending && cci & UCSI_CCI_BUSY) {
 228                 ucsi->sync_val = -EBUSY;
 229                 complete(&ucsi->sync_ack);
 230         } else if (ucsi->sync_pending &&
 231                    (cci & (UCSI_CCI_ACK_COMPLETE | UCSI_CCI_COMMAND_COMPLETE))) {
 232                 complete(&ucsi->sync_ack);
 233         }
 234 }
 235
 236 static void pmic_glink_ucsi_register(struct work_struct *work)
 237 {
 238         struct pmic_glink_ucsi *ucsi = container_of(work, struct pmic_glink_ucsi, register_work);
 239
 240         ucsi_register(ucsi->ucsi);
 241 }
 242
 243 static void pmic_glink_ucsi_callback(const void *data, size_t len, void *priv)
 244 {
 245         struct pmic_glink_ucsi *ucsi = priv;
 246         const struct pmic_glink_hdr *hdr = data;
 247
 248         switch (le32_to_cpu(hdr->opcode)) {
 249         case UC_UCSI_READ_BUF_REQ:
 250                 pmic_glink_ucsi_read_ack(ucsi, data, len);
 251                 break;
 252         case UC_UCSI_WRITE_BUF_REQ:
 253                 pmic_glink_ucsi_write_ack(ucsi, data, len);
 254                 break;
 255         case UC_UCSI_USBC_NOTIFY_IND:
 256                 schedule_work(&ucsi->notify_work);
 257                 break;
 258         };
 259 }
 260
 261 static void pmic_glink_ucsi_pdr_notify(void *priv, int state)
 262 {
 263         struct pmic_glink_ucsi *ucsi = priv;
 264
 265         if (state == SERVREG_SERVICE_STATE_UP)
 266                 schedule_work(&ucsi->register_work);
 267         else if (state == SERVREG_SERVICE_STATE_DOWN)
 268                 ucsi_unregister(ucsi->ucsi);
 269 }
 270
 271 static void pmic_glink_ucsi_destroy(void *data)
 272 {
 273         struct pmic_glink_ucsi *ucsi = data;
 274
 275         /* Protect to make sure we're not in a middle of a transaction from a glink callback */
 276         mutex_lock(&ucsi->lock);
 277         ucsi_destroy(ucsi->ucsi);
 278         mutex_unlock(&ucsi->lock);
 279 }
 280
 281 static int pmic_glink_ucsi_probe(struct auxiliary_device *adev,
 282                                  const struct auxiliary_device_id *id)
 283 {
 284         struct pmic_glink_ucsi *ucsi;
 285         struct device *dev = &adev->dev;
 286         int ret;
 287
 288         ucsi = devm_kzalloc(dev, sizeof(*ucsi), GFP_KERNEL);
 289         if (!ucsi)
 290                 return -ENOMEM;
 291
 292         ucsi->dev = dev;
 293         dev_set_drvdata(dev, ucsi);
 294
 295         INIT_WORK(&ucsi->notify_work, pmic_glink_ucsi_notify);
 296         INIT_WORK(&ucsi->register_work, pmic_glink_ucsi_register);
 297         init_completion(&ucsi->read_ack);
 298         init_completion(&ucsi->write_ack);
 299         init_completion(&ucsi->sync_ack);
 300         mutex_init(&ucsi->lock);
 301
 302         ucsi->ucsi = ucsi_create(dev, &pmic_glink_ucsi_ops);
 303         if (IS_ERR(ucsi->ucsi))
 304                 return PTR_ERR(ucsi->ucsi);
 305
 306         /* Make sure we destroy *after* pmic_glink unregister */
 307         ret = devm_add_action_or_reset(dev, pmic_glink_ucsi_destroy, ucsi);
 308         if (ret)
 309                 return ret;
 310
 311         ucsi_set_drvdata(ucsi->ucsi, ucsi);
 312
 313         ucsi->client = devm_pmic_glink_register_client(dev,
 314                                                        PMIC_GLINK_OWNER_USBC,
 315                                                        pmic_glink_ucsi_callback,
 316                                                        pmic_glink_ucsi_pdr_notify,
 317                                                        ucsi);
 318         return PTR_ERR_OR_ZERO(ucsi->client);
 319 }
 320
 321 static void pmic_glink_ucsi_remove(struct auxiliary_device *adev)
 322 {
 323         struct pmic_glink_ucsi *ucsi = dev_get_drvdata(&adev->dev);
 324
 325         /* Unregister first to stop having read & writes */
 326         ucsi_unregister(ucsi->ucsi);
 327 }
 328
 329 static const struct auxiliary_device_id pmic_glink_ucsi_id_table[] = {
 330         { .name = "pmic_glink.ucsi", },
 331         {},
 332 };
 333 MODULE_DEVICE_TABLE(auxiliary, pmic_glink_ucsi_id_table);
 334
 335 static struct auxiliary_driver pmic_glink_ucsi_driver = {
 336         .name = "pmic_glink_ucsi",
 337         .probe = pmic_glink_ucsi_probe,
 338         .remove = pmic_glink_ucsi_remove,
 339         .id_table = pmic_glink_ucsi_id_table,
 340 };
 341
 342 module_auxiliary_driver(pmic_glink_ucsi_driver);
 343
 344 MODULE_DESCRIPTION("Qualcomm PMIC GLINK UCSI driver");
 345 MODULE_LICENSE("GPL");