This source file includes following definitions.
- i2c_amd_dma_map
- i2c_amd_dma_unmap
- i2c_amd_start_cmd
- i2c_amd_cmd_completion
- i2c_amd_check_cmd_completion
- i2c_amd_enable_set
- i2c_amd_xfer_msg
- i2c_amd_xfer
- i2c_amd_func
- i2c_amd_suspend
- i2c_amd_resume
- i2c_amd_get_bus_speed
- i2c_amd_probe
- i2c_amd_remove
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
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(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
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(i2c_common->dma_buf, i2c_common->msg, 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(&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, "%s readdata:%*ph\n",
92 __func__, event->r.length,
93 i2c_common->msg->buf);
94
95 complete(&i2c_dev->cmd_complete);
96 }
97
98 static int i2c_amd_check_cmd_completion(struct amd_i2c_dev *i2c_dev)
99 {
100 struct amd_i2c_common *i2c_common = &i2c_dev->common;
101 unsigned long timeout;
102
103 timeout = wait_for_completion_timeout(&i2c_dev->cmd_complete,
104 i2c_dev->adap.timeout);
105
106 if ((i2c_common->reqcmd == i2c_read ||
107 i2c_common->reqcmd == i2c_write) &&
108 i2c_common->msg->len > 32)
109 i2c_amd_dma_unmap(i2c_common);
110
111 if (timeout == 0) {
112 amd_mp2_rw_timeout(i2c_common);
113 return -ETIMEDOUT;
114 }
115
116 amd_mp2_process_event(i2c_common);
117
118 if (!i2c_common->cmd_success)
119 return -EIO;
120
121 return 0;
122 }
123
124 static int i2c_amd_enable_set(struct amd_i2c_dev *i2c_dev, bool enable)
125 {
126 struct amd_i2c_common *i2c_common = &i2c_dev->common;
127
128 i2c_amd_start_cmd(i2c_dev);
129 amd_mp2_bus_enable_set(i2c_common, enable);
130
131 return i2c_amd_check_cmd_completion(i2c_dev);
132 }
133
134 static int i2c_amd_xfer_msg(struct amd_i2c_dev *i2c_dev, struct i2c_msg *pmsg)
135 {
136 struct amd_i2c_common *i2c_common = &i2c_dev->common;
137
138 i2c_amd_start_cmd(i2c_dev);
139 i2c_common->msg = pmsg;
140
141 if (pmsg->len > 32)
142 if (i2c_amd_dma_map(i2c_common))
143 return -EIO;
144
145 if (pmsg->flags & I2C_M_RD)
146 amd_mp2_rw(i2c_common, i2c_read);
147 else
148 amd_mp2_rw(i2c_common, i2c_write);
149
150 return i2c_amd_check_cmd_completion(i2c_dev);
151 }
152
153 static int i2c_amd_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
154 {
155 struct amd_i2c_dev *i2c_dev = i2c_get_adapdata(adap);
156 int i;
157 struct i2c_msg *pmsg;
158 int err;
159
160
161 if (unlikely(!i2c_dev->common.mp2_dev))
162 return -EINVAL;
163
164 amd_mp2_pm_runtime_get(i2c_dev->common.mp2_dev);
165
166 for (i = 0; i < num; i++) {
167 pmsg = &msgs[i];
168 err = i2c_amd_xfer_msg(i2c_dev, pmsg);
169 if (err)
170 break;
171 }
172
173 amd_mp2_pm_runtime_put(i2c_dev->common.mp2_dev);
174 return err ? err : num;
175 }
176
177 static u32 i2c_amd_func(struct i2c_adapter *a)
178 {
179 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
180 }
181
182 static const struct i2c_algorithm i2c_amd_algorithm = {
183 .master_xfer = i2c_amd_xfer,
184 .functionality = i2c_amd_func,
185 };
186
187 #ifdef CONFIG_PM
188 static int i2c_amd_suspend(struct amd_i2c_common *i2c_common)
189 {
190 struct amd_i2c_dev *i2c_dev = amd_i2c_dev_common(i2c_common);
191
192 i2c_amd_enable_set(i2c_dev, false);
193 return 0;
194 }
195
196 static int i2c_amd_resume(struct amd_i2c_common *i2c_common)
197 {
198 struct amd_i2c_dev *i2c_dev = amd_i2c_dev_common(i2c_common);
199
200 return i2c_amd_enable_set(i2c_dev, true);
201 }
202 #endif
203
204 static enum speed_enum i2c_amd_get_bus_speed(struct platform_device *pdev)
205 {
206 u32 acpi_speed;
207 int i;
208 static const u32 supported_speeds[] = {
209 0, 100000, 400000, 1000000, 1400000, 3400000
210 };
211
212 acpi_speed = i2c_acpi_find_bus_speed(&pdev->dev);
213
214 for (i = 1; i < ARRAY_SIZE(supported_speeds); i++) {
215 if (acpi_speed < supported_speeds[i])
216 break;
217 }
218 acpi_speed = supported_speeds[i - 1];
219
220 switch (acpi_speed) {
221 case 100000:
222 return speed100k;
223 case 400000:
224 return speed400k;
225 case 1000000:
226 return speed1000k;
227 case 1400000:
228 return speed1400k;
229 case 3400000:
230 return speed3400k;
231 default:
232 return speed400k;
233 }
234 }
235
236 static const struct i2c_adapter_quirks amd_i2c_dev_quirks = {
237 .max_read_len = AMD_MP2_I2C_MAX_RW_LENGTH,
238 .max_write_len = AMD_MP2_I2C_MAX_RW_LENGTH,
239 };
240
241 static int i2c_amd_probe(struct platform_device *pdev)
242 {
243 int ret;
244 struct amd_i2c_dev *i2c_dev;
245 acpi_handle handle = ACPI_HANDLE(&pdev->dev);
246 struct acpi_device *adev;
247 struct amd_mp2_dev *mp2_dev;
248 const char *uid;
249
250 if (acpi_bus_get_device(handle, &adev))
251 return -ENODEV;
252
253
254
255
256
257 mp2_dev = amd_mp2_find_device();
258 if (!mp2_dev || !mp2_dev->probed)
259
260 return -EPROBE_DEFER;
261
262 i2c_dev = devm_kzalloc(&pdev->dev, sizeof(*i2c_dev), GFP_KERNEL);
263 if (!i2c_dev)
264 return -ENOMEM;
265
266 i2c_dev->common.mp2_dev = mp2_dev;
267 i2c_dev->pdev = pdev;
268 platform_set_drvdata(pdev, i2c_dev);
269
270 i2c_dev->common.cmd_completion = &i2c_amd_cmd_completion;
271 #ifdef CONFIG_PM
272 i2c_dev->common.suspend = &i2c_amd_suspend;
273 i2c_dev->common.resume = &i2c_amd_resume;
274 #endif
275
276 uid = adev->pnp.unique_id;
277 if (!uid) {
278 dev_err(&pdev->dev, "missing UID/bus id!\n");
279 return -EINVAL;
280 } else if (strcmp(uid, "0") == 0) {
281 i2c_dev->common.bus_id = 0;
282 } else if (strcmp(uid, "1") == 0) {
283 i2c_dev->common.bus_id = 1;
284 } else {
285 dev_err(&pdev->dev, "incorrect UID/bus id \"%s\"!\n", uid);
286 return -EINVAL;
287 }
288 dev_dbg(&pdev->dev, "bus id is %u\n", i2c_dev->common.bus_id);
289
290
291 amd_mp2_pm_runtime_get(mp2_dev);
292
293 i2c_dev->common.reqcmd = i2c_none;
294 if (amd_mp2_register_cb(&i2c_dev->common))
295 return -EINVAL;
296 device_link_add(&i2c_dev->pdev->dev, &mp2_dev->pci_dev->dev,
297 DL_FLAG_AUTOREMOVE_CONSUMER);
298
299 i2c_dev->common.i2c_speed = i2c_amd_get_bus_speed(pdev);
300
301
302 i2c_dev->adap.owner = THIS_MODULE;
303 i2c_dev->adap.algo = &i2c_amd_algorithm;
304 i2c_dev->adap.quirks = &amd_i2c_dev_quirks;
305 i2c_dev->adap.dev.parent = &pdev->dev;
306 i2c_dev->adap.algo_data = i2c_dev;
307 i2c_dev->adap.timeout = AMD_I2C_TIMEOUT;
308 ACPI_COMPANION_SET(&i2c_dev->adap.dev, ACPI_COMPANION(&pdev->dev));
309 i2c_dev->adap.dev.of_node = pdev->dev.of_node;
310 snprintf(i2c_dev->adap.name, sizeof(i2c_dev->adap.name),
311 "AMD MP2 i2c bus %u", i2c_dev->common.bus_id);
312 i2c_set_adapdata(&i2c_dev->adap, i2c_dev);
313
314 init_completion(&i2c_dev->cmd_complete);
315
316
317 if (i2c_amd_enable_set(i2c_dev, true))
318 dev_err(&pdev->dev, "initial bus enable failed\n");
319
320
321 ret = i2c_add_adapter(&i2c_dev->adap);
322
323 amd_mp2_pm_runtime_put(mp2_dev);
324
325 if (ret < 0)
326 dev_err(&pdev->dev, "i2c add adapter failed = %d\n", ret);
327
328 return ret;
329 }
330
331 static int i2c_amd_remove(struct platform_device *pdev)
332 {
333 struct amd_i2c_dev *i2c_dev = platform_get_drvdata(pdev);
334 struct amd_i2c_common *i2c_common = &i2c_dev->common;
335
336 i2c_lock_bus(&i2c_dev->adap, I2C_LOCK_ROOT_ADAPTER);
337
338 i2c_amd_enable_set(i2c_dev, false);
339 amd_mp2_unregister_cb(i2c_common);
340 i2c_common->mp2_dev = NULL;
341
342 i2c_unlock_bus(&i2c_dev->adap, I2C_LOCK_ROOT_ADAPTER);
343
344 i2c_del_adapter(&i2c_dev->adap);
345 return 0;
346 }
347
348 static const struct acpi_device_id i2c_amd_acpi_match[] = {
349 { "AMDI0011" },
350 { },
351 };
352 MODULE_DEVICE_TABLE(acpi, i2c_amd_acpi_match);
353
354 static struct platform_driver i2c_amd_plat_driver = {
355 .probe = i2c_amd_probe,
356 .remove = i2c_amd_remove,
357 .driver = {
358 .name = "i2c_amd_mp2",
359 .acpi_match_table = ACPI_PTR(i2c_amd_acpi_match),
360 },
361 };
362 module_platform_driver(i2c_amd_plat_driver);
363
364 MODULE_DESCRIPTION("AMD(R) MP2 I2C Platform Driver");
365 MODULE_AUTHOR("Nehal Shah <nehal-bakulchandra.shah@amd.com>");
366 MODULE_AUTHOR("Elie Morisse <syniurge@gmail.com>");
367 MODULE_LICENSE("Dual BSD/GPL");