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 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 	/* Set up intx irq */
315 	writel(0, privdata->mmio + AMD_P2C_MSG_INTEN);
316 	pci_intx(pci_dev, 1);
317 	rc = devm_request_irq(&pci_dev->dev, pci_dev->irq, amd_mp2_irq_isr,
318 			      IRQF_SHARED, dev_name(&pci_dev->dev), privdata);
319 	if (rc)
320 		pci_err(pci_dev, "Failure requesting irq %i: %d\n",
321 			pci_dev->irq, rc);
322 
323 	return rc;
324 
325 err_dma_mask:
326 	pci_clear_master(pci_dev);
327 err_pci_enable:
328 	pci_set_drvdata(pci_dev, NULL);
329 	return rc;
330 }
331 
amd_mp2_pci_probe(struct pci_dev * pci_dev,const struct pci_device_id * id)332 static int amd_mp2_pci_probe(struct pci_dev *pci_dev,
333 			     const struct pci_device_id *id)
334 {
335 	struct amd_mp2_dev *privdata;
336 	int rc;
337 
338 	privdata = devm_kzalloc(&pci_dev->dev, sizeof(*privdata), GFP_KERNEL);
339 	if (!privdata)
340 		return -ENOMEM;
341 
342 	privdata->pci_dev = pci_dev;
343 	rc = amd_mp2_pci_init(privdata, pci_dev);
344 	if (rc)
345 		return rc;
346 
347 	mutex_init(&privdata->c2p_lock);
348 
349 	pm_runtime_set_autosuspend_delay(&pci_dev->dev, 1000);
350 	pm_runtime_use_autosuspend(&pci_dev->dev);
351 	pm_runtime_put_autosuspend(&pci_dev->dev);
352 	pm_runtime_allow(&pci_dev->dev);
353 
354 	privdata->probed = true;
355 
356 	pci_info(pci_dev, "MP2 device registered.\n");
357 	return 0;
358 }
359 
amd_mp2_pci_remove(struct pci_dev * pci_dev)360 static void amd_mp2_pci_remove(struct pci_dev *pci_dev)
361 {
362 	struct amd_mp2_dev *privdata = pci_get_drvdata(pci_dev);
363 
364 	pm_runtime_forbid(&pci_dev->dev);
365 	pm_runtime_get_noresume(&pci_dev->dev);
366 
367 	pci_intx(pci_dev, 0);
368 	pci_clear_master(pci_dev);
369 
370 	amd_mp2_clear_reg(privdata);
371 }
372 
373 #ifdef CONFIG_PM
amd_mp2_pci_suspend(struct device * dev)374 static int amd_mp2_pci_suspend(struct device *dev)
375 {
376 	struct pci_dev *pci_dev = to_pci_dev(dev);
377 	struct amd_mp2_dev *privdata = pci_get_drvdata(pci_dev);
378 	struct amd_i2c_common *i2c_common;
379 	unsigned int bus_id;
380 	int ret = 0;
381 
382 	for (bus_id = 0; bus_id < 2; bus_id++) {
383 		i2c_common = privdata->busses[bus_id];
384 		if (i2c_common)
385 			i2c_common->suspend(i2c_common);
386 	}
387 
388 	ret = pci_save_state(pci_dev);
389 	if (ret) {
390 		pci_err(pci_dev, "pci_save_state failed = %d\n", ret);
391 		return ret;
392 	}
393 
394 	pci_disable_device(pci_dev);
395 	return ret;
396 }
397 
amd_mp2_pci_resume(struct device * dev)398 static int amd_mp2_pci_resume(struct device *dev)
399 {
400 	struct pci_dev *pci_dev = to_pci_dev(dev);
401 	struct amd_mp2_dev *privdata = pci_get_drvdata(pci_dev);
402 	struct amd_i2c_common *i2c_common;
403 	unsigned int bus_id;
404 	int ret = 0;
405 
406 	pci_restore_state(pci_dev);
407 	ret = pci_enable_device(pci_dev);
408 	if (ret < 0) {
409 		pci_err(pci_dev, "pci_enable_device failed = %d\n", ret);
410 		return ret;
411 	}
412 
413 	for (bus_id = 0; bus_id < 2; bus_id++) {
414 		i2c_common = privdata->busses[bus_id];
415 		if (i2c_common) {
416 			ret = i2c_common->resume(i2c_common);
417 			if (ret < 0)
418 				return ret;
419 		}
420 	}
421 
422 	return ret;
423 }
424 
425 static UNIVERSAL_DEV_PM_OPS(amd_mp2_pci_pm_ops, amd_mp2_pci_suspend,
426 			    amd_mp2_pci_resume, NULL);
427 #endif /* CONFIG_PM */
428 
429 static const struct pci_device_id amd_mp2_pci_tbl[] = {
430 	{PCI_VDEVICE(AMD, PCI_DEVICE_ID_AMD_MP2)},
431 	{0}
432 };
433 MODULE_DEVICE_TABLE(pci, amd_mp2_pci_tbl);
434 
435 static struct pci_driver amd_mp2_pci_driver = {
436 	.name		= "i2c_amd_mp2",
437 	.id_table	= amd_mp2_pci_tbl,
438 	.probe		= amd_mp2_pci_probe,
439 	.remove		= amd_mp2_pci_remove,
440 #ifdef CONFIG_PM
441 	.driver = {
442 		.pm	= &amd_mp2_pci_pm_ops,
443 	},
444 #endif
445 };
446 module_pci_driver(amd_mp2_pci_driver);
447 
amd_mp2_find_device(void)448 struct amd_mp2_dev *amd_mp2_find_device(void)
449 {
450 	struct device *dev;
451 	struct pci_dev *pci_dev;
452 
453 	dev = driver_find_next_device(&amd_mp2_pci_driver.driver, NULL);
454 	if (!dev)
455 		return NULL;
456 
457 	pci_dev = to_pci_dev(dev);
458 	return (struct amd_mp2_dev *)pci_get_drvdata(pci_dev);
459 }
460 EXPORT_SYMBOL_GPL(amd_mp2_find_device);
461 
462 MODULE_DESCRIPTION("AMD(R) PCI-E MP2 I2C Controller Driver");
463 MODULE_AUTHOR("Shyam Sundar S K <Shyam-sundar.S-k@amd.com>");
464 MODULE_AUTHOR("Elie Morisse <syniurge@gmail.com>");
465 MODULE_LICENSE("Dual BSD/GPL");
466