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 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 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 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 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 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 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 } 74 EXPORT_SYMBOL_GPL(amd_mp2_bus_enable_set); 75 76 static 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 87 int 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 } 109 EXPORT_SYMBOL_GPL(amd_mp2_rw); 110 111 static 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 136 static 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 190 void 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 } 206 EXPORT_SYMBOL_GPL(amd_mp2_process_event); 207 208 static 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 248 void 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 } 253 EXPORT_SYMBOL_GPL(amd_mp2_rw_timeout); 254 255 int 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 } 272 EXPORT_SYMBOL_GPL(amd_mp2_register_cb); 273 274 int 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 } 282 EXPORT_SYMBOL_GPL(amd_mp2_unregister_cb); 283 284 static 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 295 static 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 /* Set up intx irq */ 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 335 err_dma_mask: 336 pci_clear_master(pci_dev); 337 err_pci_enable: 338 pci_set_drvdata(pci_dev, NULL); 339 return rc; 340 } 341 342 static 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 370 static 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 384 static 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 409 static 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 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 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