1
2
3
4
5
6
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
19struct 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
28static 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
44static 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
59static 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
69static 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, 60 * HZ))
82 ret = -ETIMEDOUT;
83
84out_clear_bit:
85 clear_bit(COMMAND_PENDING, &ua->flags);
86
87 return ret;
88}
89
90static 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
96static 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
114static 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
136 status = acpi_release_memory(ACPI_HANDLE(&pdev->dev), res, 1);
137 if (ACPI_FAILURE(status))
138 return -ENOMEM;
139
140
141
142
143
144
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
186static 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
199static const struct acpi_device_id ucsi_acpi_match[] = {
200 { "PNP0CA0", 0 },
201 { },
202};
203MODULE_DEVICE_TABLE(acpi, ucsi_acpi_match);
204
205static 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
214module_platform_driver(ucsi_acpi_platform_driver);
215
216MODULE_AUTHOR("Heikki Krogerus <heikki.krogerus@linux.intel.com>");
217MODULE_LICENSE("GPL v2");
218MODULE_DESCRIPTION("UCSI ACPI driver");
219
