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/property.h> 10 #include <linux/soc/qcom/pdr.h> 11 #include <linux/usb/typec_mux.h> 12 #include <linux/gpio/consumer.h> 13 #include <linux/soc/qcom/pmic_glink.h> 14 #include "ucsi.h" 15 16 #define PMIC_GLINK_MAX_PORTS 2 17 18 #define UCSI_BUF_SIZE 48 19 20 #define MSG_TYPE_REQ_RESP 1 21 #define UCSI_BUF_SIZE 48 22 23 #define UC_NOTIFY_RECEIVER_UCSI 0x0 24 #define UC_UCSI_READ_BUF_REQ 0x11 25 #define UC_UCSI_WRITE_BUF_REQ 0x12 26 #define UC_UCSI_USBC_NOTIFY_IND 0x13 27 28 struct ucsi_read_buf_req_msg { 29 struct pmic_glink_hdr hdr; 30 }; 31 32 struct ucsi_read_buf_resp_msg { 33 struct pmic_glink_hdr hdr; 34 u8 buf[UCSI_BUF_SIZE]; 35 u32 ret_code; 36 }; 37 38 struct ucsi_write_buf_req_msg { 39 struct pmic_glink_hdr hdr; 40 u8 buf[UCSI_BUF_SIZE]; 41 u32 reserved; 42 }; 43 44 struct ucsi_write_buf_resp_msg { 45 struct pmic_glink_hdr hdr; 46 u32 ret_code; 47 }; 48 49 struct ucsi_notify_ind_msg { 50 struct pmic_glink_hdr hdr; 51 u32 notification; 52 u32 receiver; 53 u32 reserved; 54 }; 55 56 struct pmic_glink_ucsi { 57 struct device *dev; 58 59 struct gpio_desc *port_orientation[PMIC_GLINK_MAX_PORTS]; 60 struct typec_switch *port_switch[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 79 static 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 111 out_unlock: 112 mutex_unlock(&ucsi->lock); 113 114 return ret; 115 } 116 117 static 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 146 static 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 159 static 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 ret = -ETIMEDOUT; 179 } else if (ucsi->sync_val) { 180 dev_err(ucsi->dev, "sync write returned: %d\n", ucsi->sync_val); 181 } 182 183 ucsi->sync_pending = false; 184 185 return ret; 186 } 187 188 static const struct ucsi_operations pmic_glink_ucsi_ops = { 189 .read = pmic_glink_ucsi_read, 190 .sync_write = pmic_glink_ucsi_sync_write, 191 .async_write = pmic_glink_ucsi_async_write 192 }; 193 194 static void pmic_glink_ucsi_read_ack(struct pmic_glink_ucsi *ucsi, const void *data, int len) 195 { 196 const struct ucsi_read_buf_resp_msg *resp = data; 197 198 if (resp->ret_code) 199 return; 200 201 memcpy(ucsi->read_buf, resp->buf, UCSI_BUF_SIZE); 202 complete(&ucsi->read_ack); 203 } 204 205 static void pmic_glink_ucsi_write_ack(struct pmic_glink_ucsi *ucsi, const void *data, int len) 206 { 207 const struct ucsi_write_buf_resp_msg *resp = data; 208 209 if (resp->ret_code) 210 return; 211 212 ucsi->sync_val = resp->ret_code; 213 complete(&ucsi->write_ack); 214 } 215 216 static void pmic_glink_ucsi_notify(struct work_struct *work) 217 { 218 struct pmic_glink_ucsi *ucsi = container_of(work, struct pmic_glink_ucsi, notify_work); 219 unsigned int con_num; 220 u32 cci; 221 int ret; 222 223 ret = pmic_glink_ucsi_read(ucsi->ucsi, UCSI_CCI, &cci, sizeof(cci)); 224 if (ret) { 225 dev_err(ucsi->dev, "failed to read CCI on notification\n"); 226 return; 227 } 228 229 con_num = UCSI_CCI_CONNECTOR(cci); 230 if (con_num) { 231 if (con_num < PMIC_GLINK_MAX_PORTS && 232 ucsi->port_orientation[con_num - 1]) { 233 int orientation = gpiod_get_value(ucsi->port_orientation[con_num - 1]); 234 235 if (orientation >= 0) { 236 typec_switch_set(ucsi->port_switch[con_num - 1], 237 orientation ? TYPEC_ORIENTATION_REVERSE 238 : TYPEC_ORIENTATION_NORMAL); 239 } 240 } 241 242 ucsi_connector_change(ucsi->ucsi, con_num); 243 } 244 245 if (ucsi->sync_pending && cci & UCSI_CCI_BUSY) { 246 ucsi->sync_val = -EBUSY; 247 complete(&ucsi->sync_ack); 248 } else if (ucsi->sync_pending && 249 (cci & (UCSI_CCI_ACK_COMPLETE | UCSI_CCI_COMMAND_COMPLETE))) { 250 complete(&ucsi->sync_ack); 251 } 252 } 253 254 static void pmic_glink_ucsi_register(struct work_struct *work) 255 { 256 struct pmic_glink_ucsi *ucsi = container_of(work, struct pmic_glink_ucsi, register_work); 257 258 ucsi_register(ucsi->ucsi); 259 } 260 261 static void pmic_glink_ucsi_callback(const void *data, size_t len, void *priv) 262 { 263 struct pmic_glink_ucsi *ucsi = priv; 264 const struct pmic_glink_hdr *hdr = data; 265 266 switch (le32_to_cpu(hdr->opcode)) { 267 case UC_UCSI_READ_BUF_REQ: 268 pmic_glink_ucsi_read_ack(ucsi, data, len); 269 break; 270 case UC_UCSI_WRITE_BUF_REQ: 271 pmic_glink_ucsi_write_ack(ucsi, data, len); 272 break; 273 case UC_UCSI_USBC_NOTIFY_IND: 274 schedule_work(&ucsi->notify_work); 275 break; 276 }; 277 } 278 279 static void pmic_glink_ucsi_pdr_notify(void *priv, int state) 280 { 281 struct pmic_glink_ucsi *ucsi = priv; 282 283 if (state == SERVREG_SERVICE_STATE_UP) 284 schedule_work(&ucsi->register_work); 285 else if (state == SERVREG_SERVICE_STATE_DOWN) 286 ucsi_unregister(ucsi->ucsi); 287 } 288 289 static void pmic_glink_ucsi_destroy(void *data) 290 { 291 struct pmic_glink_ucsi *ucsi = data; 292 293 /* Protect to make sure we're not in a middle of a transaction from a glink callback */ 294 mutex_lock(&ucsi->lock); 295 ucsi_destroy(ucsi->ucsi); 296 mutex_unlock(&ucsi->lock); 297 } 298 299 static int pmic_glink_ucsi_probe(struct auxiliary_device *adev, 300 const struct auxiliary_device_id *id) 301 { 302 struct pmic_glink_ucsi *ucsi; 303 struct device *dev = &adev->dev; 304 struct fwnode_handle *fwnode; 305 int ret; 306 307 ucsi = devm_kzalloc(dev, sizeof(*ucsi), GFP_KERNEL); 308 if (!ucsi) 309 return -ENOMEM; 310 311 ucsi->dev = dev; 312 dev_set_drvdata(dev, ucsi); 313 314 INIT_WORK(&ucsi->notify_work, pmic_glink_ucsi_notify); 315 INIT_WORK(&ucsi->register_work, pmic_glink_ucsi_register); 316 init_completion(&ucsi->read_ack); 317 init_completion(&ucsi->write_ack); 318 init_completion(&ucsi->sync_ack); 319 mutex_init(&ucsi->lock); 320 321 ucsi->ucsi = ucsi_create(dev, &pmic_glink_ucsi_ops); 322 if (IS_ERR(ucsi->ucsi)) 323 return PTR_ERR(ucsi->ucsi); 324 325 /* Make sure we destroy *after* pmic_glink unregister */ 326 ret = devm_add_action_or_reset(dev, pmic_glink_ucsi_destroy, ucsi); 327 if (ret) 328 return ret; 329 330 ucsi_set_drvdata(ucsi->ucsi, ucsi); 331 332 device_for_each_child_node(dev, fwnode) { 333 struct gpio_desc *desc; 334 u32 port; 335 336 ret = fwnode_property_read_u32(fwnode, "reg", &port); 337 if (ret < 0) { 338 dev_err(dev, "missing reg property of %pOFn\n", fwnode); 339 return ret; 340 } 341 342 if (port >= PMIC_GLINK_MAX_PORTS) { 343 dev_warn(dev, "invalid connector number, ignoring\n"); 344 continue; 345 } 346 347 desc = devm_gpiod_get_index_optional(&adev->dev, "orientation", port, GPIOD_IN); 348 349 /* If GPIO isn't found, continue */ 350 if (!desc) 351 continue; 352 353 if (IS_ERR(desc)) 354 return dev_err_probe(dev, PTR_ERR(desc), 355 "unable to acquire orientation gpio\n"); 356 ucsi->port_orientation[port] = desc; 357 358 ucsi->port_switch[port] = fwnode_typec_switch_get(fwnode); 359 if (IS_ERR(ucsi->port_switch[port])) 360 return dev_err_probe(dev, PTR_ERR(ucsi->port_switch[port]), 361 "failed to acquire orientation-switch\n"); 362 } 363 364 ucsi->client = devm_pmic_glink_register_client(dev, 365 PMIC_GLINK_OWNER_USBC, 366 pmic_glink_ucsi_callback, 367 pmic_glink_ucsi_pdr_notify, 368 ucsi); 369 return PTR_ERR_OR_ZERO(ucsi->client); 370 } 371 372 static void pmic_glink_ucsi_remove(struct auxiliary_device *adev) 373 { 374 struct pmic_glink_ucsi *ucsi = dev_get_drvdata(&adev->dev); 375 376 /* Unregister first to stop having read & writes */ 377 ucsi_unregister(ucsi->ucsi); 378 } 379 380 static const struct auxiliary_device_id pmic_glink_ucsi_id_table[] = { 381 { .name = "pmic_glink.ucsi", }, 382 {}, 383 }; 384 MODULE_DEVICE_TABLE(auxiliary, pmic_glink_ucsi_id_table); 385 386 static struct auxiliary_driver pmic_glink_ucsi_driver = { 387 .name = "pmic_glink_ucsi", 388 .probe = pmic_glink_ucsi_probe, 389 .remove = pmic_glink_ucsi_remove, 390 .id_table = pmic_glink_ucsi_id_table, 391 }; 392 393 module_auxiliary_driver(pmic_glink_ucsi_driver); 394 395 MODULE_DESCRIPTION("Qualcomm PMIC GLINK UCSI driver"); 396 MODULE_LICENSE("GPL"); 397