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 (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"); 346