1 | // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause |
2 | /* |
3 | * AMD MP2 platform driver |
4 | * |
5 | * Setup the I2C adapters enumerated in the ACPI namespace. |
6 | * MP2 controllers have 2 separate busses, up to 2 I2C adapters may be listed. |
7 | * |
8 | * Authors: Nehal Bakulchandra Shah <Nehal-bakulchandra.shah@amd.com> |
9 | * Elie Morisse <syniurge@gmail.com> |
10 | */ |
11 | |
12 | #include <linux/acpi.h> |
13 | #include <linux/kernel.h> |
14 | #include <linux/module.h> |
15 | #include <linux/platform_device.h> |
16 | #include <linux/slab.h> |
17 | #include <linux/types.h> |
18 | |
19 | #include "i2c-amd-mp2.h" |
20 | |
21 | #define AMD_MP2_I2C_MAX_RW_LENGTH ((1 << 12) - 1) |
22 | #define AMD_I2C_TIMEOUT (msecs_to_jiffies(250)) |
23 | |
24 | /** |
25 | * struct amd_i2c_dev - MP2 bus/i2c adapter context |
26 | * @common: shared context with the MP2 PCI driver |
27 | * @pdev: platform driver node |
28 | * @adap: i2c adapter |
29 | * @cmd_complete: xfer completion object |
30 | */ |
31 | struct amd_i2c_dev { |
32 | struct amd_i2c_common common; |
33 | struct platform_device *pdev; |
34 | struct i2c_adapter adap; |
35 | struct completion cmd_complete; |
36 | }; |
37 | |
38 | #define amd_i2c_dev_common(__common) \ |
39 | container_of(__common, struct amd_i2c_dev, common) |
40 | |
41 | static int i2c_amd_dma_map(struct amd_i2c_common *i2c_common) |
42 | { |
43 | struct device *dev_pci = &i2c_common->mp2_dev->pci_dev->dev; |
44 | struct amd_i2c_dev *i2c_dev = amd_i2c_dev_common(i2c_common); |
45 | enum dma_data_direction dma_direction = |
46 | i2c_common->msg->flags & I2C_M_RD ? |
47 | DMA_FROM_DEVICE : DMA_TO_DEVICE; |
48 | |
49 | i2c_common->dma_buf = i2c_get_dma_safe_msg_buf(msg: i2c_common->msg, threshold: 0); |
50 | i2c_common->dma_addr = dma_map_single(dev_pci, i2c_common->dma_buf, |
51 | i2c_common->msg->len, |
52 | dma_direction); |
53 | |
54 | if (unlikely(dma_mapping_error(dev_pci, i2c_common->dma_addr))) { |
55 | dev_err(&i2c_dev->pdev->dev, |
56 | "Error while mapping dma buffer %p\n" , |
57 | i2c_common->dma_buf); |
58 | return -EIO; |
59 | } |
60 | |
61 | return 0; |
62 | } |
63 | |
64 | static void i2c_amd_dma_unmap(struct amd_i2c_common *i2c_common) |
65 | { |
66 | struct device *dev_pci = &i2c_common->mp2_dev->pci_dev->dev; |
67 | enum dma_data_direction dma_direction = |
68 | i2c_common->msg->flags & I2C_M_RD ? |
69 | DMA_FROM_DEVICE : DMA_TO_DEVICE; |
70 | |
71 | dma_unmap_single(dev_pci, i2c_common->dma_addr, |
72 | i2c_common->msg->len, dma_direction); |
73 | |
74 | i2c_put_dma_safe_msg_buf(buf: i2c_common->dma_buf, msg: i2c_common->msg, xferred: true); |
75 | } |
76 | |
77 | static void i2c_amd_start_cmd(struct amd_i2c_dev *i2c_dev) |
78 | { |
79 | struct amd_i2c_common *i2c_common = &i2c_dev->common; |
80 | |
81 | reinit_completion(x: &i2c_dev->cmd_complete); |
82 | i2c_common->cmd_success = false; |
83 | } |
84 | |
85 | static void i2c_amd_cmd_completion(struct amd_i2c_common *i2c_common) |
86 | { |
87 | struct amd_i2c_dev *i2c_dev = amd_i2c_dev_common(i2c_common); |
88 | union i2c_event *event = &i2c_common->eventval; |
89 | |
90 | if (event->r.status == i2c_readcomplete_event) |
91 | dev_dbg(&i2c_dev->pdev->dev, "readdata:%*ph\n" , event->r.length, |
92 | i2c_common->msg->buf); |
93 | |
94 | complete(&i2c_dev->cmd_complete); |
95 | } |
96 | |
97 | static int i2c_amd_check_cmd_completion(struct amd_i2c_dev *i2c_dev) |
98 | { |
99 | struct amd_i2c_common *i2c_common = &i2c_dev->common; |
100 | unsigned long timeout; |
101 | |
102 | timeout = wait_for_completion_timeout(x: &i2c_dev->cmd_complete, |
103 | timeout: i2c_dev->adap.timeout); |
104 | |
105 | if ((i2c_common->reqcmd == i2c_read || |
106 | i2c_common->reqcmd == i2c_write) && |
107 | i2c_common->msg->len > 32) |
108 | i2c_amd_dma_unmap(i2c_common); |
109 | |
110 | if (timeout == 0) { |
111 | amd_mp2_rw_timeout(i2c_common); |
112 | return -ETIMEDOUT; |
113 | } |
114 | |
115 | amd_mp2_process_event(i2c_common); |
116 | |
117 | if (!i2c_common->cmd_success) |
118 | return -EIO; |
119 | |
120 | return 0; |
121 | } |
122 | |
123 | static int i2c_amd_enable_set(struct amd_i2c_dev *i2c_dev, bool enable) |
124 | { |
125 | struct amd_i2c_common *i2c_common = &i2c_dev->common; |
126 | |
127 | i2c_amd_start_cmd(i2c_dev); |
128 | amd_mp2_bus_enable_set(i2c_common, enable); |
129 | |
130 | return i2c_amd_check_cmd_completion(i2c_dev); |
131 | } |
132 | |
133 | static int i2c_amd_xfer_msg(struct amd_i2c_dev *i2c_dev, struct i2c_msg *pmsg) |
134 | { |
135 | struct amd_i2c_common *i2c_common = &i2c_dev->common; |
136 | |
137 | i2c_amd_start_cmd(i2c_dev); |
138 | i2c_common->msg = pmsg; |
139 | |
140 | if (pmsg->len > 32) |
141 | if (i2c_amd_dma_map(i2c_common)) |
142 | return -EIO; |
143 | |
144 | if (pmsg->flags & I2C_M_RD) |
145 | amd_mp2_rw(i2c_common, reqcmd: i2c_read); |
146 | else |
147 | amd_mp2_rw(i2c_common, reqcmd: i2c_write); |
148 | |
149 | return i2c_amd_check_cmd_completion(i2c_dev); |
150 | } |
151 | |
152 | static int i2c_amd_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num) |
153 | { |
154 | struct amd_i2c_dev *i2c_dev = i2c_get_adapdata(adap); |
155 | int i; |
156 | struct i2c_msg *pmsg; |
157 | int err = 0; |
158 | |
159 | /* the adapter might have been deleted while waiting for the bus lock */ |
160 | if (unlikely(!i2c_dev->common.mp2_dev)) |
161 | return -EINVAL; |
162 | |
163 | amd_mp2_pm_runtime_get(mp2_dev: i2c_dev->common.mp2_dev); |
164 | |
165 | for (i = 0; i < num; i++) { |
166 | pmsg = &msgs[i]; |
167 | err = i2c_amd_xfer_msg(i2c_dev, pmsg); |
168 | if (err) |
169 | break; |
170 | } |
171 | |
172 | amd_mp2_pm_runtime_put(mp2_dev: i2c_dev->common.mp2_dev); |
173 | return err ? err : num; |
174 | } |
175 | |
176 | static u32 i2c_amd_func(struct i2c_adapter *a) |
177 | { |
178 | return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; |
179 | } |
180 | |
181 | static const struct i2c_algorithm i2c_amd_algorithm = { |
182 | .master_xfer = i2c_amd_xfer, |
183 | .functionality = i2c_amd_func, |
184 | }; |
185 | |
186 | #ifdef CONFIG_PM |
187 | static int i2c_amd_suspend(struct amd_i2c_common *i2c_common) |
188 | { |
189 | struct amd_i2c_dev *i2c_dev = amd_i2c_dev_common(i2c_common); |
190 | |
191 | i2c_amd_enable_set(i2c_dev, enable: false); |
192 | return 0; |
193 | } |
194 | |
195 | static int i2c_amd_resume(struct amd_i2c_common *i2c_common) |
196 | { |
197 | struct amd_i2c_dev *i2c_dev = amd_i2c_dev_common(i2c_common); |
198 | |
199 | return i2c_amd_enable_set(i2c_dev, enable: true); |
200 | } |
201 | #endif |
202 | |
203 | static const u32 supported_speeds[] = { |
204 | I2C_MAX_HIGH_SPEED_MODE_FREQ, |
205 | I2C_MAX_TURBO_MODE_FREQ, |
206 | I2C_MAX_FAST_MODE_PLUS_FREQ, |
207 | I2C_MAX_FAST_MODE_FREQ, |
208 | I2C_MAX_STANDARD_MODE_FREQ, |
209 | }; |
210 | |
211 | static enum speed_enum i2c_amd_get_bus_speed(struct platform_device *pdev) |
212 | { |
213 | u32 acpi_speed; |
214 | int i; |
215 | |
216 | acpi_speed = i2c_acpi_find_bus_speed(dev: &pdev->dev); |
217 | /* round down to the lowest standard speed */ |
218 | for (i = 0; i < ARRAY_SIZE(supported_speeds); i++) { |
219 | if (acpi_speed >= supported_speeds[i]) |
220 | break; |
221 | } |
222 | acpi_speed = i < ARRAY_SIZE(supported_speeds) ? supported_speeds[i] : 0; |
223 | |
224 | switch (acpi_speed) { |
225 | case I2C_MAX_STANDARD_MODE_FREQ: |
226 | return speed100k; |
227 | case I2C_MAX_FAST_MODE_FREQ: |
228 | return speed400k; |
229 | case I2C_MAX_FAST_MODE_PLUS_FREQ: |
230 | return speed1000k; |
231 | case I2C_MAX_TURBO_MODE_FREQ: |
232 | return speed1400k; |
233 | case I2C_MAX_HIGH_SPEED_MODE_FREQ: |
234 | return speed3400k; |
235 | default: |
236 | return speed400k; |
237 | } |
238 | } |
239 | |
240 | static const struct i2c_adapter_quirks amd_i2c_dev_quirks = { |
241 | .max_read_len = AMD_MP2_I2C_MAX_RW_LENGTH, |
242 | .max_write_len = AMD_MP2_I2C_MAX_RW_LENGTH, |
243 | }; |
244 | |
245 | static int i2c_amd_probe(struct platform_device *pdev) |
246 | { |
247 | struct device *dev = &pdev->dev; |
248 | int ret; |
249 | struct amd_i2c_dev *i2c_dev; |
250 | struct amd_mp2_dev *mp2_dev; |
251 | u64 uid; |
252 | |
253 | ret = acpi_dev_uid_to_integer(ACPI_COMPANION(dev), integer: &uid); |
254 | if (ret) |
255 | return dev_err_probe(dev, err: ret, fmt: "missing UID/bus id!\n" ); |
256 | if (uid >= 2) |
257 | return dev_err_probe(dev, err: -EINVAL, fmt: "incorrect UID/bus id \"%llu\"!\n" , uid); |
258 | dev_dbg(dev, "bus id is %llu\n" , uid); |
259 | |
260 | /* The ACPI namespace doesn't contain information about which MP2 PCI |
261 | * device an AMDI0011 ACPI device is related to, so assume that there's |
262 | * only one MP2 PCI device per system. |
263 | */ |
264 | mp2_dev = amd_mp2_find_device(); |
265 | if (!mp2_dev || !mp2_dev->probed) |
266 | /* The MP2 PCI device should get probed later */ |
267 | return -EPROBE_DEFER; |
268 | |
269 | i2c_dev = devm_kzalloc(dev: &pdev->dev, size: sizeof(*i2c_dev), GFP_KERNEL); |
270 | if (!i2c_dev) |
271 | return -ENOMEM; |
272 | |
273 | i2c_dev->common.bus_id = uid; |
274 | i2c_dev->common.mp2_dev = mp2_dev; |
275 | i2c_dev->pdev = pdev; |
276 | platform_set_drvdata(pdev, data: i2c_dev); |
277 | |
278 | i2c_dev->common.cmd_completion = &i2c_amd_cmd_completion; |
279 | #ifdef CONFIG_PM |
280 | i2c_dev->common.suspend = &i2c_amd_suspend; |
281 | i2c_dev->common.resume = &i2c_amd_resume; |
282 | #endif |
283 | |
284 | /* Register the adapter */ |
285 | amd_mp2_pm_runtime_get(mp2_dev); |
286 | |
287 | i2c_dev->common.reqcmd = i2c_none; |
288 | if (amd_mp2_register_cb(i2c_common: &i2c_dev->common)) |
289 | return -EINVAL; |
290 | device_link_add(consumer: &i2c_dev->pdev->dev, supplier: &mp2_dev->pci_dev->dev, |
291 | DL_FLAG_AUTOREMOVE_CONSUMER); |
292 | |
293 | i2c_dev->common.i2c_speed = i2c_amd_get_bus_speed(pdev); |
294 | |
295 | /* Setup i2c adapter description */ |
296 | i2c_dev->adap.owner = THIS_MODULE; |
297 | i2c_dev->adap.algo = &i2c_amd_algorithm; |
298 | i2c_dev->adap.quirks = &amd_i2c_dev_quirks; |
299 | i2c_dev->adap.dev.parent = &pdev->dev; |
300 | i2c_dev->adap.algo_data = i2c_dev; |
301 | i2c_dev->adap.timeout = AMD_I2C_TIMEOUT; |
302 | ACPI_COMPANION_SET(&i2c_dev->adap.dev, ACPI_COMPANION(&pdev->dev)); |
303 | i2c_dev->adap.dev.of_node = pdev->dev.of_node; |
304 | snprintf(buf: i2c_dev->adap.name, size: sizeof(i2c_dev->adap.name), |
305 | fmt: "AMD MP2 i2c bus %u" , i2c_dev->common.bus_id); |
306 | i2c_set_adapdata(adap: &i2c_dev->adap, data: i2c_dev); |
307 | |
308 | init_completion(x: &i2c_dev->cmd_complete); |
309 | |
310 | /* Enable the bus */ |
311 | if (i2c_amd_enable_set(i2c_dev, enable: true)) |
312 | dev_err(&pdev->dev, "initial bus enable failed\n" ); |
313 | |
314 | /* Attach to the i2c layer */ |
315 | ret = i2c_add_adapter(adap: &i2c_dev->adap); |
316 | |
317 | amd_mp2_pm_runtime_put(mp2_dev); |
318 | |
319 | if (ret < 0) |
320 | dev_err(&pdev->dev, "i2c add adapter failed = %d\n" , ret); |
321 | |
322 | return ret; |
323 | } |
324 | |
325 | static void i2c_amd_remove(struct platform_device *pdev) |
326 | { |
327 | struct amd_i2c_dev *i2c_dev = platform_get_drvdata(pdev); |
328 | struct amd_i2c_common *i2c_common = &i2c_dev->common; |
329 | |
330 | i2c_lock_bus(adapter: &i2c_dev->adap, I2C_LOCK_ROOT_ADAPTER); |
331 | |
332 | i2c_amd_enable_set(i2c_dev, enable: false); |
333 | amd_mp2_unregister_cb(i2c_common); |
334 | i2c_common->mp2_dev = NULL; |
335 | |
336 | i2c_unlock_bus(adapter: &i2c_dev->adap, I2C_LOCK_ROOT_ADAPTER); |
337 | |
338 | i2c_del_adapter(adap: &i2c_dev->adap); |
339 | } |
340 | |
341 | static const struct acpi_device_id i2c_amd_acpi_match[] = { |
342 | { "AMDI0011" }, |
343 | { }, |
344 | }; |
345 | MODULE_DEVICE_TABLE(acpi, i2c_amd_acpi_match); |
346 | |
347 | static struct platform_driver i2c_amd_plat_driver = { |
348 | .probe = i2c_amd_probe, |
349 | .remove_new = i2c_amd_remove, |
350 | .driver = { |
351 | .name = "i2c_amd_mp2" , |
352 | .acpi_match_table = ACPI_PTR(i2c_amd_acpi_match), |
353 | }, |
354 | }; |
355 | module_platform_driver(i2c_amd_plat_driver); |
356 | |
357 | MODULE_DESCRIPTION("AMD(R) MP2 I2C Platform Driver" ); |
358 | MODULE_AUTHOR("Nehal Shah <nehal-bakulchandra.shah@amd.com>" ); |
359 | MODULE_AUTHOR("Elie Morisse <syniurge@gmail.com>" ); |
360 | MODULE_LICENSE("Dual BSD/GPL" ); |
361 | |