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 13 #include "ucsi.h" 14 15 #define UCSI_DSM_UUID "6f8398c2-7ca4-11e4-ad36-631042b5008f" 16 #define UCSI_DSM_FUNC_WRITE 1 17 #define UCSI_DSM_FUNC_READ 2 18 19 struct ucsi_acpi { 20 struct device *dev; 21 struct ucsi *ucsi; 22 void __iomem *base; 23 struct completion complete; 24 unsigned long flags; 25 guid_t guid; 26 }; 27 28 static int ucsi_acpi_dsm(struct ucsi_acpi *ua, int func) 29 { 30 union acpi_object *obj; 31 32 obj = acpi_evaluate_dsm(ACPI_HANDLE(ua->dev), &ua->guid, 1, func, 33 NULL); 34 if (!obj) { 35 dev_err(ua->dev, "%s: failed to evaluate _DSM %d\n", 36 __func__, func); 37 return -EIO; 38 } 39 40 ACPI_FREE(obj); 41 return 0; 42 } 43 44 static int ucsi_acpi_read(struct ucsi *ucsi, unsigned int offset, 45 void *val, size_t val_len) 46 { 47 struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi); 48 int ret; 49 50 ret = ucsi_acpi_dsm(ua, UCSI_DSM_FUNC_READ); 51 if (ret) 52 return ret; 53 54 memcpy(val, (const void __force *)(ua->base + offset), val_len); 55 56 return 0; 57 } 58 59 static int ucsi_acpi_async_write(struct ucsi *ucsi, unsigned int offset, 60 const void *val, size_t val_len) 61 { 62 struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi); 63 64 memcpy((void __force *)(ua->base + offset), val, val_len); 65 66 return ucsi_acpi_dsm(ua, UCSI_DSM_FUNC_WRITE); 67 } 68 69 static int ucsi_acpi_sync_write(struct ucsi *ucsi, unsigned int offset, 70 const void *val, size_t val_len) 71 { 72 struct ucsi_acpi *ua = ucsi_get_drvdata(ucsi); 73 int ret; 74 75 set_bit(COMMAND_PENDING, &ua->flags); 76 77 ret = ucsi_acpi_async_write(ucsi, offset, val, val_len); 78 if (ret) 79 goto out_clear_bit; 80 81 if (!wait_for_completion_timeout(&ua->complete, HZ)) 82 ret = -ETIMEDOUT; 83 84 out_clear_bit: 85 clear_bit(COMMAND_PENDING, &ua->flags); 86 87 return ret; 88 } 89 90 static const struct ucsi_operations ucsi_acpi_ops = { 91 .read = ucsi_acpi_read, 92 .sync_write = ucsi_acpi_sync_write, 93 .async_write = ucsi_acpi_async_write 94 }; 95 96 static void ucsi_acpi_notify(acpi_handle handle, u32 event, void *data) 97 { 98 struct ucsi_acpi *ua = data; 99 u32 cci; 100 int ret; 101 102 ret = ucsi_acpi_read(ua->ucsi, UCSI_CCI, &cci, sizeof(cci)); 103 if (ret) 104 return; 105 106 if (UCSI_CCI_CONNECTOR(cci)) 107 ucsi_connector_change(ua->ucsi, UCSI_CCI_CONNECTOR(cci)); 108 109 if (test_bit(COMMAND_PENDING, &ua->flags) && 110 cci & (UCSI_CCI_ACK_COMPLETE | UCSI_CCI_COMMAND_COMPLETE)) 111 complete(&ua->complete); 112 } 113 114 static int ucsi_acpi_probe(struct platform_device *pdev) 115 { 116 struct acpi_device *adev = ACPI_COMPANION(&pdev->dev); 117 struct ucsi_acpi *ua; 118 struct resource *res; 119 acpi_status status; 120 int ret; 121 122 if (adev->dep_unmet) 123 return -EPROBE_DEFER; 124 125 ua = devm_kzalloc(&pdev->dev, sizeof(*ua), GFP_KERNEL); 126 if (!ua) 127 return -ENOMEM; 128 129 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 130 if (!res) { 131 dev_err(&pdev->dev, "missing memory resource\n"); 132 return -ENODEV; 133 } 134 135 /* This will make sure we can use ioremap() */ 136 status = acpi_release_memory(ACPI_HANDLE(&pdev->dev), res, 1); 137 if (ACPI_FAILURE(status)) 138 return -ENOMEM; 139 140 /* 141 * NOTE: The memory region for the data structures is used also in an 142 * operation region, which means ACPI has already reserved it. Therefore 143 * it can not be requested here, and we can not use 144 * devm_ioremap_resource(). 145 */ 146 ua->base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); 147 if (!ua->base) 148 return -ENOMEM; 149 150 ret = guid_parse(UCSI_DSM_UUID, &ua->guid); 151 if (ret) 152 return ret; 153 154 init_completion(&ua->complete); 155 ua->dev = &pdev->dev; 156 157 ua->ucsi = ucsi_create(&pdev->dev, &ucsi_acpi_ops); 158 if (IS_ERR(ua->ucsi)) 159 return PTR_ERR(ua->ucsi); 160 161 ucsi_set_drvdata(ua->ucsi, ua); 162 163 status = acpi_install_notify_handler(ACPI_HANDLE(&pdev->dev), 164 ACPI_DEVICE_NOTIFY, 165 ucsi_acpi_notify, ua); 166 if (ACPI_FAILURE(status)) { 167 dev_err(&pdev->dev, "failed to install notify handler\n"); 168 ucsi_destroy(ua->ucsi); 169 return -ENODEV; 170 } 171 172 ret = ucsi_register(ua->ucsi); 173 if (ret) { 174 acpi_remove_notify_handler(ACPI_HANDLE(&pdev->dev), 175 ACPI_DEVICE_NOTIFY, 176 ucsi_acpi_notify); 177 ucsi_destroy(ua->ucsi); 178 return ret; 179 } 180 181 platform_set_drvdata(pdev, ua); 182 183 return 0; 184 } 185 186 static int ucsi_acpi_remove(struct platform_device *pdev) 187 { 188 struct ucsi_acpi *ua = platform_get_drvdata(pdev); 189 190 ucsi_unregister(ua->ucsi); 191 ucsi_destroy(ua->ucsi); 192 193 acpi_remove_notify_handler(ACPI_HANDLE(&pdev->dev), ACPI_DEVICE_NOTIFY, 194 ucsi_acpi_notify); 195 196 return 0; 197 } 198 199 static const struct acpi_device_id ucsi_acpi_match[] = { 200 { "PNP0CA0", 0 }, 201 { }, 202 }; 203 MODULE_DEVICE_TABLE(acpi, ucsi_acpi_match); 204 205 static struct platform_driver ucsi_acpi_platform_driver = { 206 .driver = { 207 .name = "ucsi_acpi", 208 .acpi_match_table = ACPI_PTR(ucsi_acpi_match), 209 }, 210 .probe = ucsi_acpi_probe, 211 .remove = ucsi_acpi_remove, 212 }; 213 214 module_platform_driver(ucsi_acpi_platform_driver); 215 216 MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>"); 217 MODULE_LICENSE("GPL v2"); 218 MODULE_DESCRIPTION("UCSI ACPI driver"); 219