1
2
3
4
5
6
7
8
9#include <linux/dma-mapping.h>
10#include <linux/interrupt.h>
11#include <linux/module.h>
12#include <linux/pci.h>
13#include <linux/slab.h>
14
15#include "i2c-amd-mp2.h"
16
17#include <linux/io-64-nonatomic-lo-hi.h>
18
19static void amd_mp2_c2p_mutex_lock(struct amd_i2c_common *i2c_common)
20{
21 struct amd_mp2_dev *privdata = i2c_common->mp2_dev;
22
23
24 mutex_lock(&privdata->c2p_lock);
25 privdata->c2p_lock_busid = i2c_common->bus_id;
26}
27
28static void amd_mp2_c2p_mutex_unlock(struct amd_i2c_common *i2c_common)
29{
30 struct amd_mp2_dev *privdata = i2c_common->mp2_dev;
31
32 if (unlikely(privdata->c2p_lock_busid != i2c_common->bus_id)) {
33 dev_warn(ndev_dev(privdata),
34 "bus %d attempting to unlock C2P locked by bus %d\n",
35 i2c_common->bus_id, privdata->c2p_lock_busid);
36 return;
37 }
38
39 mutex_unlock(&privdata->c2p_lock);
40}
41
42static int amd_mp2_cmd(struct amd_i2c_common *i2c_common,
43 union i2c_cmd_base i2c_cmd_base)
44{
45 struct amd_mp2_dev *privdata = i2c_common->mp2_dev;
46 void __iomem *reg;
47
48 i2c_common->reqcmd = i2c_cmd_base.s.i2c_cmd;
49
50 reg = privdata->mmio + ((i2c_cmd_base.s.bus_id == 1) ?
51 AMD_C2P_MSG1 : AMD_C2P_MSG0);
52 writel(i2c_cmd_base.ul, reg);
53
54 return 0;
55}
56
57int amd_mp2_bus_enable_set(struct amd_i2c_common *i2c_common, bool enable)
58{
59 struct amd_mp2_dev *privdata = i2c_common->mp2_dev;
60 union i2c_cmd_base i2c_cmd_base;
61
62 dev_dbg(ndev_dev(privdata), "%s id: %d\n", __func__,
63 i2c_common->bus_id);
64
65 i2c_cmd_base.ul = 0;
66 i2c_cmd_base.s.i2c_cmd = enable ? i2c_enable : i2c_disable;
67 i2c_cmd_base.s.bus_id = i2c_common->bus_id;
68 i2c_cmd_base.s.i2c_speed = i2c_common->i2c_speed;
69
70 amd_mp2_c2p_mutex_lock(i2c_common);
71
72 return amd_mp2_cmd(i2c_common, i2c_cmd_base);
73}
74EXPORT_SYMBOL_GPL(amd_mp2_bus_enable_set);
75
76static void amd_mp2_cmd_rw_fill(struct amd_i2c_common *i2c_common,
77 union i2c_cmd_base *i2c_cmd_base,
78 enum i2c_cmd reqcmd)
79{
80 i2c_cmd_base->s.i2c_cmd = reqcmd;
81 i2c_cmd_base->s.bus_id = i2c_common->bus_id;
82 i2c_cmd_base->s.i2c_speed = i2c_common->i2c_speed;
83 i2c_cmd_base->s.slave_addr = i2c_common->msg->addr;
84 i2c_cmd_base->s.length = i2c_common->msg->len;
85}
86
87int amd_mp2_rw(struct amd_i2c_common *i2c_common, enum i2c_cmd reqcmd)
88{
89 struct amd_mp2_dev *privdata = i2c_common->mp2_dev;
90 union i2c_cmd_base i2c_cmd_base;
91
92 amd_mp2_cmd_rw_fill(i2c_common, &i2c_cmd_base, reqcmd);
93 amd_mp2_c2p_mutex_lock(i2c_common);
94
95 if (i2c_common->msg->len <= 32) {
96 i2c_cmd_base.s.mem_type = use_c2pmsg;
97 if (reqcmd == i2c_write)
98 memcpy_toio(privdata->mmio + AMD_C2P_MSG2,
99 i2c_common->msg->buf,
100 i2c_common->msg->len);
101 } else {
102 i2c_cmd_base.s.mem_type = use_dram;
103 writeq((u64)i2c_common->dma_addr,
104 privdata->mmio + AMD_C2P_MSG2);
105 }
106
107 return amd_mp2_cmd(i2c_common, i2c_cmd_base);
108}
109EXPORT_SYMBOL_GPL(amd_mp2_rw);
110
111static void amd_mp2_pci_check_rw_event(struct amd_i2c_common *i2c_common)
112{
113 struct amd_mp2_dev *privdata = i2c_common->mp2_dev;
114 int len = i2c_common->eventval.r.length;
115 u32 slave_addr = i2c_common->eventval.r.slave_addr;
116 bool err = false;
117
118 if (unlikely(len != i2c_common->msg->len)) {
119 dev_err(ndev_dev(privdata),
120 "length %d in event doesn't match buffer length %d!\n",
121 len, i2c_common->msg->len);
122 err = true;
123 }
124
125 if (unlikely(slave_addr != i2c_common->msg->addr)) {
126 dev_err(ndev_dev(privdata),
127 "unexpected slave address %x (expected: %x)!\n",
128 slave_addr, i2c_common->msg->addr);
129 err = true;
130 }
131
132 if (!err)
133 i2c_common->cmd_success = true;
134}
135
136static void __amd_mp2_process_event(struct amd_i2c_common *i2c_common)
137{
138 struct amd_mp2_dev *privdata = i2c_common->mp2_dev;
139 enum status_type sts = i2c_common->eventval.r.status;
140 enum response_type res = i2c_common->eventval.r.response;
141 int len = i2c_common->eventval.r.length;
142
143 if (res != command_success) {
144 if (res != command_failed)
145 dev_err(ndev_dev(privdata), "invalid response to i2c command!\n");
146 return;
147 }
148
149 switch (i2c_common->reqcmd) {
150 case i2c_read:
151 if (sts == i2c_readcomplete_event) {
152 amd_mp2_pci_check_rw_event(i2c_common);
153 if (len <= 32)
154 memcpy_fromio(i2c_common->msg->buf,
155 privdata->mmio + AMD_C2P_MSG2,
156 len);
157 } else if (sts != i2c_readfail_event) {
158 dev_err(ndev_dev(privdata),
159 "invalid i2c status after read (%d)!\n", sts);
160 }
161 break;
162 case i2c_write:
163 if (sts == i2c_writecomplete_event)
164 amd_mp2_pci_check_rw_event(i2c_common);
165 else if (sts != i2c_writefail_event)
166 dev_err(ndev_dev(privdata),
167 "invalid i2c status after write (%d)!\n", sts);
168 break;
169 case i2c_enable:
170 if (sts == i2c_busenable_complete)
171 i2c_common->cmd_success = true;
172 else if (sts != i2c_busenable_failed)
173 dev_err(ndev_dev(privdata),
174 "invalid i2c status after bus enable (%d)!\n",
175 sts);
176 break;
177 case i2c_disable:
178 if (sts == i2c_busdisable_complete)
179 i2c_common->cmd_success = true;
180 else if (sts != i2c_busdisable_failed)
181 dev_err(ndev_dev(privdata),
182 "invalid i2c status after bus disable (%d)!\n",
183 sts);
184 break;
185 default:
186 break;
187 }
188}
189
190void amd_mp2_process_event(struct amd_i2c_common *i2c_common)
191{
192 struct amd_mp2_dev *privdata = i2c_common->mp2_dev;
193
194 if (unlikely(i2c_common->reqcmd == i2c_none)) {
195 dev_warn(ndev_dev(privdata),
196 "received msg but no cmd was sent (bus = %d)!\n",
197 i2c_common->bus_id);
198 return;
199 }
200
201 __amd_mp2_process_event(i2c_common);
202
203 i2c_common->reqcmd = i2c_none;
204 amd_mp2_c2p_mutex_unlock(i2c_common);
205}
206EXPORT_SYMBOL_GPL(amd_mp2_process_event);
207
208static irqreturn_t amd_mp2_irq_isr(int irq, void *dev)
209{
210 struct amd_mp2_dev *privdata = dev;
211 struct amd_i2c_common *i2c_common;
212 u32 val;
213 unsigned int bus_id;
214 void __iomem *reg;
215 enum irqreturn ret = IRQ_NONE;
216
217 for (bus_id = 0; bus_id < 2; bus_id++) {
218 i2c_common = privdata->busses[bus_id];
219 if (!i2c_common)
220 continue;
221
222 reg = privdata->mmio + ((bus_id == 0) ?
223 AMD_P2C_MSG1 : AMD_P2C_MSG2);
224 val = readl(reg);
225 if (val != 0) {
226 writel(0, reg);
227 writel(0, privdata->mmio + AMD_P2C_MSG_INTEN);
228 i2c_common->eventval.ul = val;
229 i2c_common->cmd_completion(i2c_common);
230
231 ret = IRQ_HANDLED;
232 }
233 }
234
235 if (ret != IRQ_HANDLED) {
236 val = readl(privdata->mmio + AMD_P2C_MSG_INTEN);
237 if (val != 0) {
238 writel(0, privdata->mmio + AMD_P2C_MSG_INTEN);
239 dev_warn(ndev_dev(privdata),
240 "received irq without message\n");
241 ret = IRQ_HANDLED;
242 }
243 }
244
245 return ret;
246}
247
248void amd_mp2_rw_timeout(struct amd_i2c_common *i2c_common)
249{
250 i2c_common->reqcmd = i2c_none;
251 amd_mp2_c2p_mutex_unlock(i2c_common);
252}
253EXPORT_SYMBOL_GPL(amd_mp2_rw_timeout);
254
255int amd_mp2_register_cb(struct amd_i2c_common *i2c_common)
256{
257 struct amd_mp2_dev *privdata = i2c_common->mp2_dev;
258
259 if (i2c_common->bus_id > 1)
260 return -EINVAL;
261
262 if (privdata->busses[i2c_common->bus_id]) {
263 dev_err(ndev_dev(privdata),
264 "Bus %d already taken!\n", i2c_common->bus_id);
265 return -EINVAL;
266 }
267
268 privdata->busses[i2c_common->bus_id] = i2c_common;
269
270 return 0;
271}
272EXPORT_SYMBOL_GPL(amd_mp2_register_cb);
273
274int amd_mp2_unregister_cb(struct amd_i2c_common *i2c_common)
275{
276 struct amd_mp2_dev *privdata = i2c_common->mp2_dev;
277
278 privdata->busses[i2c_common->bus_id] = NULL;
279
280 return 0;
281}
282EXPORT_SYMBOL_GPL(amd_mp2_unregister_cb);
283
284static void amd_mp2_clear_reg(struct amd_mp2_dev *privdata)
285{
286 int reg;
287
288 for (reg = AMD_C2P_MSG0; reg <= AMD_C2P_MSG9; reg += 4)
289 writel(0, privdata->mmio + reg);
290
291 for (reg = AMD_P2C_MSG1; reg <= AMD_P2C_MSG2; reg += 4)
292 writel(0, privdata->mmio + reg);
293}
294
295static int amd_mp2_pci_init(struct amd_mp2_dev *privdata,
296 struct pci_dev *pci_dev)
297{
298 int rc;
299
300 pci_set_drvdata(pci_dev, privdata);
301
302 rc = pcim_enable_device(pci_dev);
303 if (rc) {
304 dev_err(ndev_dev(privdata), "Failed to enable MP2 PCI device\n");
305 goto err_pci_enable;
306 }
307
308 rc = pcim_iomap_regions(pci_dev, 1 << 2, pci_name(pci_dev));
309 if (rc) {
310 dev_err(ndev_dev(privdata), "I/O memory remapping failed\n");
311 goto err_pci_enable;
312 }
313 privdata->mmio = pcim_iomap_table(pci_dev)[2];
314
315 pci_set_master(pci_dev);
316
317 rc = pci_set_dma_mask(pci_dev, DMA_BIT_MASK(64));
318 if (rc) {
319 rc = pci_set_dma_mask(pci_dev, DMA_BIT_MASK(32));
320 if (rc)
321 goto err_dma_mask;
322 }
323
324
325 writel(0, privdata->mmio + AMD_P2C_MSG_INTEN);
326 pci_intx(pci_dev, 1);
327 rc = devm_request_irq(&pci_dev->dev, pci_dev->irq, amd_mp2_irq_isr,
328 IRQF_SHARED, dev_name(&pci_dev->dev), privdata);
329 if (rc)
330 dev_err(&pci_dev->dev, "Failure requesting irq %i: %d\n",
331 pci_dev->irq, rc);
332
333 return rc;
334
335err_dma_mask:
336 pci_clear_master(pci_dev);
337err_pci_enable:
338 pci_set_drvdata(pci_dev, NULL);
339 return rc;
340}
341
342static int amd_mp2_pci_probe(struct pci_dev *pci_dev,
343 const struct pci_device_id *id)
344{
345 struct amd_mp2_dev *privdata;
346 int rc;
347
348 privdata = devm_kzalloc(&pci_dev->dev, sizeof(*privdata), GFP_KERNEL);
349 if (!privdata)
350 return -ENOMEM;
351
352 rc = amd_mp2_pci_init(privdata, pci_dev);
353 if (rc)
354 return rc;
355
356 mutex_init(&privdata->c2p_lock);
357 privdata->pci_dev = pci_dev;
358
359 pm_runtime_set_autosuspend_delay(&pci_dev->dev, 1000);
360 pm_runtime_use_autosuspend(&pci_dev->dev);
361 pm_runtime_put_autosuspend(&pci_dev->dev);
362 pm_runtime_allow(&pci_dev->dev);
363
364 privdata->probed = true;
365
366 dev_info(&pci_dev->dev, "MP2 device registered.\n");
367 return 0;
368}
369
370static void amd_mp2_pci_remove(struct pci_dev *pci_dev)
371{
372 struct amd_mp2_dev *privdata = pci_get_drvdata(pci_dev);
373
374 pm_runtime_forbid(&pci_dev->dev);
375 pm_runtime_get_noresume(&pci_dev->dev);
376
377 pci_intx(pci_dev, 0);
378 pci_clear_master(pci_dev);
379
380 amd_mp2_clear_reg(privdata);
381}
382
383#ifdef CONFIG_PM
384static int amd_mp2_pci_suspend(struct device *dev)
385{
386 struct pci_dev *pci_dev = to_pci_dev(dev);
387 struct amd_mp2_dev *privdata = pci_get_drvdata(pci_dev);
388 struct amd_i2c_common *i2c_common;
389 unsigned int bus_id;
390 int ret = 0;
391
392 for (bus_id = 0; bus_id < 2; bus_id++) {
393 i2c_common = privdata->busses[bus_id];
394 if (i2c_common)
395 i2c_common->suspend(i2c_common);
396 }
397
398 ret = pci_save_state(pci_dev);
399 if (ret) {
400 dev_err(ndev_dev(privdata),
401 "pci_save_state failed = %d\n", ret);
402 return ret;
403 }
404
405 pci_disable_device(pci_dev);
406 return ret;
407}
408
409static int amd_mp2_pci_resume(struct device *dev)
410{
411 struct pci_dev *pci_dev = to_pci_dev(dev);
412 struct amd_mp2_dev *privdata = pci_get_drvdata(pci_dev);
413 struct amd_i2c_common *i2c_common;
414 unsigned int bus_id;
415 int ret = 0;
416
417 pci_restore_state(pci_dev);
418 ret = pci_enable_device(pci_dev);
419 if (ret < 0) {
420 dev_err(ndev_dev(privdata),
421 "pci_enable_device failed = %d\n", ret);
422 return ret;
423 }
424
425 for (bus_id = 0; bus_id < 2; bus_id++) {
426 i2c_common = privdata->busses[bus_id];
427 if (i2c_common) {
428 ret = i2c_common->resume(i2c_common);
429 if (ret < 0)
430 return ret;
431 }
432 }
433
434 return ret;
435}
436
437static UNIVERSAL_DEV_PM_OPS(amd_mp2_pci_pm_ops, amd_mp2_pci_suspend,
438 amd_mp2_pci_resume, NULL);
439#endif
440
441static const struct pci_device_id amd_mp2_pci_tbl[] = {
442 {PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_MP2)},
443 {0}
444};
445MODULE_DEVICE_TABLE(pci, amd_mp2_pci_tbl);
446
447static struct pci_driver amd_mp2_pci_driver = {
448 .name = "i2c_amd_mp2",
449 .id_table = amd_mp2_pci_tbl,
450 .probe = amd_mp2_pci_probe,
451 .remove = amd_mp2_pci_remove,
452#ifdef CONFIG_PM
453 .driver = {
454 .pm = &amd_mp2_pci_pm_ops,
455 },
456#endif
457};
458module_pci_driver(amd_mp2_pci_driver);
459
460static int amd_mp2_device_match(struct device *dev, const void *data)
461{
462 return 1;
463}
464
465struct amd_mp2_dev *amd_mp2_find_device(void)
466{
467 struct device *dev;
468 struct pci_dev *pci_dev;
469
470 dev = driver_find_device(&amd_mp2_pci_driver.driver, NULL, NULL,
471 amd_mp2_device_match);
472 if (!dev)
473 return NULL;
474
475 pci_dev = to_pci_dev(dev);
476 return (struct amd_mp2_dev *)pci_get_drvdata(pci_dev);
477}
478EXPORT_SYMBOL_GPL(amd_mp2_find_device);
479
480MODULE_DESCRIPTION("AMD(R) PCI-E MP2 I2C Controller Driver");
481MODULE_AUTHOR("Shyam Sundar S K <Shyam-sundar.S-k@amd.com>");
482MODULE_AUTHOR("Elie Morisse <syniurge@gmail.com>");
483MODULE_LICENSE("Dual BSD/GPL");
484
