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