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/mutex.h> 9#include <linux/of_device.h> 10#include <linux/property.h> 11#include <linux/soc/qcom/pdr.h> 12#include <linux/usb/typec_mux.h> 13#include <linux/gpio/consumer.h> 14#include <linux/soc/qcom/pmic_glink.h> 15#include "ucsi.h" 16 17#define PMIC_GLINK_MAX_PORTS 2 18 19#define UCSI_BUF_SIZE 48 20 21#define MSG_TYPE_REQ_RESP 1 22#define UCSI_BUF_SIZE 48 23 24#define UC_NOTIFY_RECEIVER_UCSI 0x0 25#define UC_UCSI_READ_BUF_REQ 0x11 26#define UC_UCSI_WRITE_BUF_REQ 0x12 27#define UC_UCSI_USBC_NOTIFY_IND 0x13 28 29struct ucsi_read_buf_req_msg { 30 struct pmic_glink_hdr hdr; 31}; 32 33struct ucsi_read_buf_resp_msg { 34 struct pmic_glink_hdr hdr; 35 u8 buf[UCSI_BUF_SIZE]; 36 u32 ret_code; 37}; 38 39struct ucsi_write_buf_req_msg { 40 struct pmic_glink_hdr hdr; 41 u8 buf[UCSI_BUF_SIZE]; 42 u32 reserved; 43}; 44 45struct ucsi_write_buf_resp_msg { 46 struct pmic_glink_hdr hdr; 47 u32 ret_code; 48}; 49 50struct ucsi_notify_ind_msg { 51 struct pmic_glink_hdr hdr; 52 u32 notification; 53 u32 receiver; 54 u32 reserved; 55}; 56 57struct pmic_glink_ucsi { 58 struct device *dev; 59 60 struct gpio_desc *port_orientation[PMIC_GLINK_MAX_PORTS]; 61 62 struct pmic_glink_client *client; 63 64 struct ucsi *ucsi; 65 struct completion read_ack; 66 struct completion write_ack; 67 struct completion sync_ack; 68 bool sync_pending; 69 struct mutex lock; /* protects concurrent access to PMIC Glink interface */ 70 71 int sync_val; 72 73 struct work_struct notify_work; 74 struct work_struct register_work; 75 76 u8 read_buf[UCSI_BUF_SIZE]; 77}; 78 79static int pmic_glink_ucsi_read(struct ucsi *__ucsi, unsigned int offset, 80 void *val, size_t val_len) 81{ 82 struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi); 83 struct ucsi_read_buf_req_msg req = {}; 84 unsigned long left; 85 int ret; 86 87 req.hdr.owner = PMIC_GLINK_OWNER_USBC; 88 req.hdr.type = MSG_TYPE_REQ_RESP; 89 req.hdr.opcode = UC_UCSI_READ_BUF_REQ; 90 91 mutex_lock(&ucsi->lock); 92 memset(ucsi->read_buf, 0, sizeof(ucsi->read_buf)); 93 reinit_completion(&ucsi->read_ack); 94 95 ret = pmic_glink_send(ucsi->client, &req, sizeof(req)); 96 if (ret < 0) { 97 dev_err(ucsi->dev, "failed to send UCSI read request: %d\n", ret); 98 goto out_unlock; 99 } 100 101 left = wait_for_completion_timeout(&ucsi->read_ack, 5 * HZ); 102 if (!left) { 103 dev_err(ucsi->dev, "timeout waiting for UCSI read response\n"); 104 ret = -ETIMEDOUT; 105 goto out_unlock; 106 } 107 108 memcpy(val, &ucsi->read_buf[offset], val_len); 109 ret = 0; 110 111out_unlock: 112 mutex_unlock(&ucsi->lock); 113 114 return ret; 115} 116 117static int pmic_glink_ucsi_locked_write(struct pmic_glink_ucsi *ucsi, unsigned int offset, 118 const void *val, size_t val_len) 119{ 120 struct ucsi_write_buf_req_msg req = {}; 121 unsigned long left; 122 int ret; 123 124 req.hdr.owner = PMIC_GLINK_OWNER_USBC; 125 req.hdr.type = MSG_TYPE_REQ_RESP; 126 req.hdr.opcode = UC_UCSI_WRITE_BUF_REQ; 127 memcpy(&req.buf[offset], val, val_len); 128 129 reinit_completion(&ucsi->write_ack); 130 131 ret = pmic_glink_send(ucsi->client, &req, sizeof(req)); 132 if (ret < 0) { 133 dev_err(ucsi->dev, "failed to send UCSI write request: %d\n", ret); 134 return ret; 135 } 136 137 left = wait_for_completion_timeout(&ucsi->write_ack, 5 * HZ); 138 if (!left) { 139 dev_err(ucsi->dev, "timeout waiting for UCSI write response\n"); 140 return -ETIMEDOUT; 141 } 142 143 return 0; 144} 145 146static int pmic_glink_ucsi_async_write(struct ucsi *__ucsi, unsigned int offset, 147 const void *val, size_t val_len) 148{ 149 struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi); 150 int ret; 151 152 mutex_lock(&ucsi->lock); 153 ret = pmic_glink_ucsi_locked_write(ucsi, offset, val, val_len); 154 mutex_unlock(&ucsi->lock); 155 156 return ret; 157} 158 159static int pmic_glink_ucsi_sync_write(struct ucsi *__ucsi, unsigned int offset, 160 const void *val, size_t val_len) 161{ 162 struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(__ucsi); 163 unsigned long left; 164 int ret; 165 166 /* TOFIX: Downstream forces recipient to CON when UCSI_GET_ALTERNATE_MODES command */ 167 168 mutex_lock(&ucsi->lock); 169 ucsi->sync_val = 0; 170 reinit_completion(&ucsi->sync_ack); 171 ucsi->sync_pending = true; 172 ret = pmic_glink_ucsi_locked_write(ucsi, offset, val, val_len); 173 mutex_unlock(&ucsi->lock); 174 175 left = wait_for_completion_timeout(&ucsi->sync_ack, 5 * HZ); 176 if (!left) { 177 dev_err(ucsi->dev, "timeout waiting for UCSI sync write response\n"); 178 /* return 0 here and let core UCSI code handle the CCI_BUSY */ 179 ret = 0; 180 } else if (ucsi->sync_val) { 181 dev_err(ucsi->dev, "sync write returned: %d\n", ucsi->sync_val); 182 } 183 184 ucsi->sync_pending = false; 185 186 return ret; 187} 188 189static void pmic_glink_ucsi_update_connector(struct ucsi_connector *con) 190{ 191 struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(con->ucsi); 192 int i; 193 194 for (i = 0; i < PMIC_GLINK_MAX_PORTS; i++) { 195 if (ucsi->port_orientation[i]) 196 con->typec_cap.orientation_aware = true; 197 } 198} 199 200static void pmic_glink_ucsi_connector_status(struct ucsi_connector *con) 201{ 202 struct pmic_glink_ucsi *ucsi = ucsi_get_drvdata(con->ucsi); 203 int orientation; 204 205 if (con->num >= PMIC_GLINK_MAX_PORTS || 206 !ucsi->port_orientation[con->num - 1]) 207 return; 208 209 orientation = gpiod_get_value(ucsi->port_orientation[con->num - 1]); 210 if (orientation >= 0) { 211 typec_set_orientation(con->port, 212 orientation ? 213 TYPEC_ORIENTATION_REVERSE : 214 TYPEC_ORIENTATION_NORMAL); 215 } 216} 217 218static const struct ucsi_operations pmic_glink_ucsi_ops = { 219 .read = pmic_glink_ucsi_read, 220 .sync_write = pmic_glink_ucsi_sync_write, 221 .async_write = pmic_glink_ucsi_async_write, 222 .update_connector = pmic_glink_ucsi_update_connector, 223 .connector_status = pmic_glink_ucsi_connector_status, 224}; 225 226static void pmic_glink_ucsi_read_ack(struct pmic_glink_ucsi *ucsi, const void *data, int len) 227{ 228 const struct ucsi_read_buf_resp_msg *resp = data; 229 230 if (resp->ret_code) 231 return; 232 233 memcpy(ucsi->read_buf, resp->buf, UCSI_BUF_SIZE); 234 complete(&ucsi->read_ack); 235} 236 237static void pmic_glink_ucsi_write_ack(struct pmic_glink_ucsi *ucsi, const void *data, int len) 238{ 239 const struct ucsi_write_buf_resp_msg *resp = data; 240 241 if (resp->ret_code) 242 return; 243 244 ucsi->sync_val = resp->ret_code; 245 complete(&ucsi->write_ack); 246} 247 248static void pmic_glink_ucsi_notify(struct work_struct *work) 249{ 250 struct pmic_glink_ucsi *ucsi = container_of(work, struct pmic_glink_ucsi, notify_work); 251 unsigned int con_num; 252 u32 cci; 253 int ret; 254 255 ret = pmic_glink_ucsi_read(ucsi->ucsi, UCSI_CCI, &cci, sizeof(cci)); 256 if (ret) { 257 dev_err(ucsi->dev, "failed to read CCI on notification\n"); 258 return; 259 } 260 261 con_num = UCSI_CCI_CONNECTOR(cci); 262 if (con_num) 263 ucsi_connector_change(ucsi->ucsi, con_num); 264 265 if (ucsi->sync_pending && 266 (cci & (UCSI_CCI_ACK_COMPLETE | UCSI_CCI_COMMAND_COMPLETE))) { 267 complete(&ucsi->sync_ack); 268 } 269} 270 271static void pmic_glink_ucsi_register(struct work_struct *work) 272{ 273 struct pmic_glink_ucsi *ucsi = container_of(work, struct pmic_glink_ucsi, register_work); 274 275 ucsi_register(ucsi->ucsi); 276} 277 278static void pmic_glink_ucsi_callback(const void *data, size_t len, void *priv) 279{ 280 struct pmic_glink_ucsi *ucsi = priv; 281 const struct pmic_glink_hdr *hdr = data; 282 283 switch (le32_to_cpu(hdr->opcode)) { 284 case UC_UCSI_READ_BUF_REQ: 285 pmic_glink_ucsi_read_ack(ucsi, data, len); 286 break; 287 case UC_UCSI_WRITE_BUF_REQ: 288 pmic_glink_ucsi_write_ack(ucsi, data, len); 289 break; 290 case UC_UCSI_USBC_NOTIFY_IND: 291 schedule_work(&ucsi->notify_work); 292 break; 293 }; 294} 295 296static void pmic_glink_ucsi_pdr_notify(void *priv, int state) 297{ 298 struct pmic_glink_ucsi *ucsi = priv; 299 300 if (state == SERVREG_SERVICE_STATE_UP) 301 schedule_work(&ucsi->register_work); 302 else if (state == SERVREG_SERVICE_STATE_DOWN) 303 ucsi_unregister(ucsi->ucsi); 304} 305 306static void pmic_glink_ucsi_destroy(void *data) 307{ 308 struct pmic_glink_ucsi *ucsi = data; 309 310 /* Protect to make sure we're not in a middle of a transaction from a glink callback */ 311 mutex_lock(&ucsi->lock); 312 ucsi_destroy(ucsi->ucsi); 313 mutex_unlock(&ucsi->lock); 314} 315 316static unsigned long quirk_sc8180x = UCSI_NO_PARTNER_PDOS; 317static unsigned long quirk_sc8280xp = UCSI_NO_PARTNER_PDOS | UCSI_DELAY_DEVICE_PDOS; 318static unsigned long quirk_sm8450 = UCSI_DELAY_DEVICE_PDOS; 319 320static const struct of_device_id pmic_glink_ucsi_of_quirks[] = { 321 { .compatible = "qcom,qcm6490-pmic-glink", .data = &quirk_sc8280xp, }, 322 { .compatible = "qcom,sc8180x-pmic-glink", .data = &quirk_sc8180x, }, 323 { .compatible = "qcom,sc8280xp-pmic-glink", .data = &quirk_sc8280xp, }, 324 { .compatible = "qcom,sm8350-pmic-glink", .data = &quirk_sc8180x, }, 325 { .compatible = "qcom,sm8450-pmic-glink", .data = &quirk_sm8450, }, 326 { .compatible = "qcom,sm8550-pmic-glink", .data = &quirk_sm8450, }, 327 {} 328}; 329 330static int pmic_glink_ucsi_probe(struct auxiliary_device *adev, 331 const struct auxiliary_device_id *id) 332{ 333 struct pmic_glink_ucsi *ucsi; 334 struct device *dev = &adev->dev; 335 const struct of_device_id *match; 336 struct fwnode_handle *fwnode; 337 int ret; 338 339 ucsi = devm_kzalloc(dev, sizeof(*ucsi), GFP_KERNEL); 340 if (!ucsi) 341 return -ENOMEM; 342 343 ucsi->dev = dev; 344 dev_set_drvdata(dev, ucsi); 345 346 INIT_WORK(&ucsi->notify_work, pmic_glink_ucsi_notify); 347 INIT_WORK(&ucsi->register_work, pmic_glink_ucsi_register); 348 init_completion(&ucsi->read_ack); 349 init_completion(&ucsi->write_ack); 350 init_completion(&ucsi->sync_ack); 351 mutex_init(&ucsi->lock); 352 353 ucsi->ucsi = ucsi_create(dev, &pmic_glink_ucsi_ops); 354 if (IS_ERR(ucsi->ucsi)) 355 return PTR_ERR(ucsi->ucsi); 356 357 /* Make sure we destroy *after* pmic_glink unregister */ 358 ret = devm_add_action_or_reset(dev, pmic_glink_ucsi_destroy, ucsi); 359 if (ret) 360 return ret; 361 362 match = of_match_device(pmic_glink_ucsi_of_quirks, dev->parent); 363 if (match) 364 ucsi->ucsi->quirks = *(unsigned long *)match->data; 365 366 ucsi_set_drvdata(ucsi->ucsi, ucsi); 367 368 device_for_each_child_node(dev, fwnode) { 369 struct gpio_desc *desc; 370 u32 port; 371 372 ret = fwnode_property_read_u32(fwnode, "reg", &port); 373 if (ret < 0) { 374 dev_err(dev, "missing reg property of %pOFn\n", fwnode); 375 return ret; 376 } 377 378 if (port >= PMIC_GLINK_MAX_PORTS) { 379 dev_warn(dev, "invalid connector number, ignoring\n"); 380 continue; 381 } 382 383 desc = devm_gpiod_get_index_optional(&adev->dev, "orientation", port, GPIOD_IN); 384 385 /* If GPIO isn't found, continue */ 386 if (!desc) 387 continue; 388 389 if (IS_ERR(desc)) 390 return dev_err_probe(dev, PTR_ERR(desc), 391 "unable to acquire orientation gpio\n"); 392 ucsi->port_orientation[port] = desc; 393 } 394 395 ucsi->client = devm_pmic_glink_register_client(dev, 396 PMIC_GLINK_OWNER_USBC, 397 pmic_glink_ucsi_callback, 398 pmic_glink_ucsi_pdr_notify, 399 ucsi); 400 return PTR_ERR_OR_ZERO(ucsi->client); 401} 402 403static void pmic_glink_ucsi_remove(struct auxiliary_device *adev) 404{ 405 struct pmic_glink_ucsi *ucsi = dev_get_drvdata(&adev->dev); 406 407 /* Unregister first to stop having read & writes */ 408 ucsi_unregister(ucsi->ucsi); 409} 410 411static const struct auxiliary_device_id pmic_glink_ucsi_id_table[] = { 412 { .name = "pmic_glink.ucsi", }, 413 {}, 414}; 415MODULE_DEVICE_TABLE(auxiliary, pmic_glink_ucsi_id_table); 416 417static struct auxiliary_driver pmic_glink_ucsi_driver = { 418 .name = "pmic_glink_ucsi", 419 .probe = pmic_glink_ucsi_probe, 420 .remove = pmic_glink_ucsi_remove, 421 .id_table = pmic_glink_ucsi_id_table, 422}; 423 424module_auxiliary_driver(pmic_glink_ucsi_driver); 425 426MODULE_DESCRIPTION("Qualcomm PMIC GLINK UCSI driver"); 427MODULE_LICENSE("GPL"); 428