1// SPDX-License-Identifier: GPL-2.0 2/* 3 * UCSI ACPI driver 4 * 5 * Copyright (C) 2017, Intel Corporation 6 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com> 7 */ 8 9#include <linux/platform_device.h> 10#include <linux/module.h> 11#include <linux/acpi.h> 12#include <linux/dmi.h> 13 14#include "ucsi.h" 15 16#define UCSI_DSM_UUID "6f8398c2-7ca4-11e4-ad36-631042b5008f" 17#define UCSI_DSM_FUNC_WRITE 1 18#define UCSI_DSM_FUNC_READ 2 19 20struct ucsi_acpi { 21 struct device *dev; 22 struct ucsi *ucsi; 23 void *base; 24 struct completion complete; 25 unsigned long flags; 26#define UCSI_ACPI_COMMAND_PENDING 1 27#define UCSI_ACPI_ACK_PENDING 2 28 guid_t guid; 29 u64 cmd; 30}; 31 32static int ucsi_acpi_dsm(struct ucsi_acpi *ua, int func) 33{ 34 union acpi_object *obj; 35 36 obj = acpi_evaluate_dsm(ACPI_HANDLE(ua->dev), &ua->guid, 1, func, 37 NULL); 38 if (!obj) { 39 dev_err(ua->dev, "%s: failed to evaluate _DSM %d\n", 40 __func__, func); 41 return -EIO; 42 } 43 44 ACPI_FREE(obj); 45 return 0; 46} 47 48static int ucsi_acpi_read(struct ucsi *ucsi, unsigned int offset, 49 void *val, size_t val_len) 50{ 51 struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi); 52 int ret; 53 54 ret = ucsi_acpi_dsm(ua, UCSI_DSM_FUNC_READ); 55 if (ret) 56 return ret; 57 58 memcpy(val, ua->base + offset, val_len); 59 60 return 0; 61} 62 63static int ucsi_acpi_async_write(struct ucsi *ucsi, unsigned int offset, 64 const void *val, size_t val_len) 65{ 66 struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi); 67 68 memcpy(ua->base + offset, val, val_len); 69 ua->cmd = *(u64 *)val; 70 71 return ucsi_acpi_dsm(ua, UCSI_DSM_FUNC_WRITE); 72} 73 74static int ucsi_acpi_sync_write(struct ucsi *ucsi, unsigned int offset, 75 const void *val, size_t val_len) 76{ 77 struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi); 78 bool ack = UCSI_COMMAND(*(u64 *)val) == UCSI_ACK_CC_CI; 79 int ret; 80 81 if (ack) 82 set_bit(UCSI_ACPI_ACK_PENDING, &ua->flags); 83 else 84 set_bit(UCSI_ACPI_COMMAND_PENDING, &ua->flags); 85 86 ret = ucsi_acpi_async_write(ucsi, offset, val, val_len); 87 if (ret) 88 goto out_clear_bit; 89 90 if (!wait_for_completion_timeout(&ua->complete, 5 * HZ)) 91 ret = -ETIMEDOUT; 92 93out_clear_bit: 94 if (ack) 95 clear_bit(UCSI_ACPI_ACK_PENDING, &ua->flags); 96 else 97 clear_bit(UCSI_ACPI_COMMAND_PENDING, &ua->flags); 98 99 return ret; 100} 101 102static const struct ucsi_operations ucsi_acpi_ops = { 103 .read = ucsi_acpi_read, 104 .sync_write = ucsi_acpi_sync_write, 105 .async_write = ucsi_acpi_async_write 106}; 107 108static int 109ucsi_zenbook_read(struct ucsi *ucsi, unsigned int offset, void *val, size_t val_len) 110{ 111 struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi); 112 int ret; 113 114 if (offset == UCSI_VERSION || UCSI_COMMAND(ua->cmd) == UCSI_PPM_RESET) { 115 ret = ucsi_acpi_dsm(ua, UCSI_DSM_FUNC_READ); 116 if (ret) 117 return ret; 118 } 119 120 memcpy(val, ua->base + offset, val_len); 121 122 return 0; 123} 124 125static const struct ucsi_operations ucsi_zenbook_ops = { 126 .read = ucsi_zenbook_read, 127 .sync_write = ucsi_acpi_sync_write, 128 .async_write = ucsi_acpi_async_write 129}; 130 131static const struct dmi_system_id ucsi_acpi_quirks[] = { 132 { 133 .matches = { 134 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."), 135 DMI_MATCH(DMI_PRODUCT_NAME, "ZenBook UX325UA_UM325UA"), 136 }, 137 .driver_data = (void *)&ucsi_zenbook_ops, 138 }, 139 { } 140}; 141 142static void ucsi_acpi_notify(acpi_handle handle, u32 event, void *data) 143{ 144 struct ucsi_acpi *ua = data; 145 u32 cci; 146 int ret; 147 148 ret = ua->ucsi->ops->read(ua->ucsi, UCSI_CCI, &cci, sizeof(cci)); 149 if (ret) 150 return; 151 152 if (UCSI_CCI_CONNECTOR(cci)) 153 ucsi_connector_change(ua->ucsi, UCSI_CCI_CONNECTOR(cci)); 154 155 if (cci & UCSI_CCI_ACK_COMPLETE && 156 test_bit(UCSI_ACPI_ACK_PENDING, &ua->flags)) 157 complete(&ua->complete); 158 if (cci & UCSI_CCI_COMMAND_COMPLETE && 159 test_bit(UCSI_ACPI_COMMAND_PENDING, &ua->flags)) 160 complete(&ua->complete); 161} 162 163static int ucsi_acpi_probe(struct platform_device *pdev) 164{ 165 struct acpi_device *adev = ACPI_COMPANION(&pdev->dev); 166 const struct ucsi_operations *ops = &ucsi_acpi_ops; 167 const struct dmi_system_id *id; 168 struct ucsi_acpi *ua; 169 struct resource *res; 170 acpi_status status; 171 int ret; 172 173 if (adev->dep_unmet) 174 return -EPROBE_DEFER; 175 176 ua = devm_kzalloc(&pdev->dev, sizeof(*ua), GFP_KERNEL); 177 if (!ua) 178 return -ENOMEM; 179 180 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 181 if (!res) { 182 dev_err(&pdev->dev, "missing memory resource\n"); 183 return -ENODEV; 184 } 185 186 ua->base = devm_memremap(&pdev->dev, res->start, resource_size(res), MEMREMAP_WB); 187 if (IS_ERR(ua->base)) 188 return PTR_ERR(ua->base); 189 190 ret = guid_parse(UCSI_DSM_UUID, &ua->guid); 191 if (ret) 192 return ret; 193 194 init_completion(&ua->complete); 195 ua->dev = &pdev->dev; 196 197 id = dmi_first_match(ucsi_acpi_quirks); 198 if (id) 199 ops = id->driver_data; 200 201 ua->ucsi = ucsi_create(&pdev->dev, ops); 202 if (IS_ERR(ua->ucsi)) 203 return PTR_ERR(ua->ucsi); 204 205 ucsi_set_drvdata(ua->ucsi, ua); 206 207 status = acpi_install_notify_handler(ACPI_HANDLE(&pdev->dev), 208 ACPI_DEVICE_NOTIFY, 209 ucsi_acpi_notify, ua); 210 if (ACPI_FAILURE(status)) { 211 dev_err(&pdev->dev, "failed to install notify handler\n"); 212 ucsi_destroy(ua->ucsi); 213 return -ENODEV; 214 } 215 216 ret = ucsi_register(ua->ucsi); 217 if (ret) { 218 acpi_remove_notify_handler(ACPI_HANDLE(&pdev->dev), 219 ACPI_DEVICE_NOTIFY, 220 ucsi_acpi_notify); 221 ucsi_destroy(ua->ucsi); 222 return ret; 223 } 224 225 platform_set_drvdata(pdev, ua); 226 227 return 0; 228} 229 230static void ucsi_acpi_remove(struct platform_device *pdev) 231{ 232 struct ucsi_acpi *ua = platform_get_drvdata(pdev); 233 234 ucsi_unregister(ua->ucsi); 235 ucsi_destroy(ua->ucsi); 236 237 acpi_remove_notify_handler(ACPI_HANDLE(&pdev->dev), ACPI_DEVICE_NOTIFY, 238 ucsi_acpi_notify); 239} 240 241static int ucsi_acpi_resume(struct device *dev) 242{ 243 struct ucsi_acpi *ua = dev_get_drvdata(dev); 244 245 return ucsi_resume(ua->ucsi); 246} 247 248static DEFINE_SIMPLE_DEV_PM_OPS(ucsi_acpi_pm_ops, NULL, ucsi_acpi_resume); 249 250static const struct acpi_device_id ucsi_acpi_match[] = { 251 { "PNP0CA0", 0 }, 252 { }, 253}; 254MODULE_DEVICE_TABLE(acpi, ucsi_acpi_match); 255 256static struct platform_driver ucsi_acpi_platform_driver = { 257 .driver = { 258 .name = "ucsi_acpi", 259 .pm = pm_ptr(&ucsi_acpi_pm_ops), 260 .acpi_match_table = ACPI_PTR(ucsi_acpi_match), 261 }, 262 .probe = ucsi_acpi_probe, 263 .remove_new = ucsi_acpi_remove, 264}; 265 266module_platform_driver(ucsi_acpi_platform_driver); 267 268MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>"); 269MODULE_LICENSE("GPL v2"); 270MODULE_DESCRIPTION("UCSI ACPI driver"); 271