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