1
2
3
4
5
6
7
8
9
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
26
27
28
29
30
31struct 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
41static 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(i2c_common->msg, 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
64static 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(i2c_common->dma_buf, i2c_common->msg, true);
75}
76
77static 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(&i2c_dev->cmd_complete);
82 i2c_common->cmd_success = false;
83}
84
85static 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
97static 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(&i2c_dev->cmd_complete,
103 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
123static 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
133static 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, i2c_read);
146 else
147 amd_mp2_rw(i2c_common, i2c_write);
148
149 return i2c_amd_check_cmd_completion(i2c_dev);
150}
151
152static 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
160 if (unlikely(!i2c_dev->common.mp2_dev))
161 return -EINVAL;
162
163 amd_mp2_pm_runtime_get(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(i2c_dev->common.mp2_dev);
173 return err ? err : num;
174}
175
176static u32 i2c_amd_func(struct i2c_adapter *a)
177{
178 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
179}
180
181static const struct i2c_algorithm i2c_amd_algorithm = {
182 .master_xfer = i2c_amd_xfer,
183 .functionality = i2c_amd_func,
184};
185
186#ifdef CONFIG_PM
187static 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, false);
192 return 0;
193}
194
195static 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, true);
200}
201#endif
202
203static 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
211static 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(&pdev->dev);
217
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
240static 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
245static int i2c_amd_probe(struct platform_device *pdev)
246{
247 int ret;
248 struct amd_i2c_dev *i2c_dev;
249 acpi_handle handle = ACPI_HANDLE(&pdev->dev);
250 struct acpi_device *adev;
251 struct amd_mp2_dev *mp2_dev;
252 const char *uid;
253
254 if (acpi_bus_get_device(handle, &adev))
255 return -ENODEV;
256
257
258
259
260
261 mp2_dev = amd_mp2_find_device();
262 if (!mp2_dev || !mp2_dev->probed)
263
264 return -EPROBE_DEFER;
265
266 i2c_dev = devm_kzalloc(&pdev->dev, sizeof(*i2c_dev), GFP_KERNEL);
267 if (!i2c_dev)
268 return -ENOMEM;
269
270 i2c_dev->common.mp2_dev = mp2_dev;
271 i2c_dev->pdev = pdev;
272 platform_set_drvdata(pdev, i2c_dev);
273
274 i2c_dev->common.cmd_completion = &i2c_amd_cmd_completion;
275#ifdef CONFIG_PM
276 i2c_dev->common.suspend = &i2c_amd_suspend;
277 i2c_dev->common.resume = &i2c_amd_resume;
278#endif
279
280 uid = adev->pnp.unique_id;
281 if (!uid) {
282 dev_err(&pdev->dev, "missing UID/bus id!\n");
283 return -EINVAL;
284 } else if (strcmp(uid, "0") == 0) {
285 i2c_dev->common.bus_id = 0;
286 } else if (strcmp(uid, "1") == 0) {
287 i2c_dev->common.bus_id = 1;
288 } else {
289 dev_err(&pdev->dev, "incorrect UID/bus id \"%s\"!\n", uid);
290 return -EINVAL;
291 }
292 dev_dbg(&pdev->dev, "bus id is %u\n", i2c_dev->common.bus_id);
293
294
295 amd_mp2_pm_runtime_get(mp2_dev);
296
297 i2c_dev->common.reqcmd = i2c_none;
298 if (amd_mp2_register_cb(&i2c_dev->common))
299 return -EINVAL;
300 device_link_add(&i2c_dev->pdev->dev, &mp2_dev->pci_dev->dev,
301 DL_FLAG_AUTOREMOVE_CONSUMER);
302
303 i2c_dev->common.i2c_speed = i2c_amd_get_bus_speed(pdev);
304
305
306 i2c_dev->adap.owner = THIS_MODULE;
307 i2c_dev->adap.algo = &i2c_amd_algorithm;
308 i2c_dev->adap.quirks = &amd_i2c_dev_quirks;
309 i2c_dev->adap.dev.parent = &pdev->dev;
310 i2c_dev->adap.algo_data = i2c_dev;
311 i2c_dev->adap.timeout = AMD_I2C_TIMEOUT;
312 ACPI_COMPANION_SET(&i2c_dev->adap.dev, ACPI_COMPANION(&pdev->dev));
313 i2c_dev->adap.dev.of_node = pdev->dev.of_node;
314 snprintf(i2c_dev->adap.name, sizeof(i2c_dev->adap.name),
315 "AMD MP2 i2c bus %u", i2c_dev->common.bus_id);
316 i2c_set_adapdata(&i2c_dev->adap, i2c_dev);
317
318 init_completion(&i2c_dev->cmd_complete);
319
320
321 if (i2c_amd_enable_set(i2c_dev, true))
322 dev_err(&pdev->dev, "initial bus enable failed\n");
323
324
325 ret = i2c_add_adapter(&i2c_dev->adap);
326
327 amd_mp2_pm_runtime_put(mp2_dev);
328
329 if (ret < 0)
330 dev_err(&pdev->dev, "i2c add adapter failed = %d\n", ret);
331
332 return ret;
333}
334
335static int i2c_amd_remove(struct platform_device *pdev)
336{
337 struct amd_i2c_dev *i2c_dev = platform_get_drvdata(pdev);
338 struct amd_i2c_common *i2c_common = &i2c_dev->common;
339
340 i2c_lock_bus(&i2c_dev->adap, I2C_LOCK_ROOT_ADAPTER);
341
342 i2c_amd_enable_set(i2c_dev, false);
343 amd_mp2_unregister_cb(i2c_common);
344 i2c_common->mp2_dev = NULL;
345
346 i2c_unlock_bus(&i2c_dev->adap, I2C_LOCK_ROOT_ADAPTER);
347
348 i2c_del_adapter(&i2c_dev->adap);
349 return 0;
350}
351
352static const struct acpi_device_id i2c_amd_acpi_match[] = {
353 { "AMDI0011" },
354 { },
355};
356MODULE_DEVICE_TABLE(acpi, i2c_amd_acpi_match);
357
358static struct platform_driver i2c_amd_plat_driver = {
359 .probe = i2c_amd_probe,
360 .remove = i2c_amd_remove,
361 .driver = {
362 .name = "i2c_amd_mp2",
363 .acpi_match_table = ACPI_PTR(i2c_amd_acpi_match),
364 },
365};
366module_platform_driver(i2c_amd_plat_driver);
367
368MODULE_DESCRIPTION("AMD(R) MP2 I2C Platform Driver");
369MODULE_AUTHOR("Nehal Shah <nehal-bakulchandra.shah@amd.com>");
370MODULE_AUTHOR("Elie Morisse <syniurge@gmail.com>");
371MODULE_LICENSE("Dual BSD/GPL");
372
