1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) KEBA Industrial Automation Gmbh 2024 4 * 5 * Driver for KEBA system FPGA 6 * 7 * The KEBA system FPGA implements various devices. This driver registers 8 * auxiliary devices for every device within the FPGA. 9 */ 10 11 #include <linux/device.h> 12 #include <linux/i2c.h> 13 #include <linux/misc/keba.h> 14 #include <linux/module.h> 15 #include <linux/mtd/partitions.h> 16 #include <linux/nvmem-consumer.h> 17 #include <linux/nvmem-provider.h> 18 #include <linux/pci.h> 19 #include <linux/spi/flash.h> 20 #include <linux/spi/spi.h> 21 22 #define CP500 "cp500" 23 24 #define PCI_VENDOR_ID_KEBA 0xCEBA 25 #define PCI_DEVICE_ID_KEBA_CP035 0x2706 26 #define PCI_DEVICE_ID_KEBA_CP505 0x2703 27 #define PCI_DEVICE_ID_KEBA_CP520 0x2696 28 29 #define CP500_SYS_BAR 0 30 #define CP500_ECM_BAR 1 31 32 /* BAR 0 registers */ 33 #define CP500_VERSION_REG 0x00 34 #define CP500_RECONFIG_REG 0x11 /* upper 8-bits of STARTUP register */ 35 #define CP500_PRESENT_REG 0x20 36 #define CP500_AXI_REG 0x40 37 38 /* Bits in BUILD_REG */ 39 #define CP500_BUILD_TEST 0x8000 /* FPGA test version */ 40 41 /* Bits in RECONFIG_REG */ 42 #define CP500_RECFG_REQ 0x01 /* reconfigure FPGA on next reset */ 43 44 /* Bits in PRESENT_REG */ 45 #define CP500_PRESENT_FAN0 0x01 46 47 /* MSIX */ 48 #define CP500_AXI_MSIX 3 49 #define CP500_NUM_MSIX 8 50 #define CP500_NUM_MSIX_NO_MMI 2 51 #define CP500_NUM_MSIX_NO_AXI 3 52 53 /* EEPROM */ 54 #define CP500_EEPROM_DA_OFFSET 0x016F 55 #define CP500_EEPROM_DA_ESC_TYPE_MASK 0x01 56 #define CP500_EEPROM_ESC_LAN9252 0x00 57 #define CP500_EEPROM_ESC_ET1100 0x01 58 #define CP500_EEPROM_CPU_NAME "cpu_eeprom" 59 #define CP500_EEPROM_CPU_OFFSET 0 60 #define CP500_EEPROM_CPU_SIZE 3072 61 #define CP500_EEPROM_USER_NAME "user_eeprom" 62 #define CP500_EEPROM_USER_OFFSET 3072 63 #define CP500_EEPROM_USER_SIZE 1024 64 65 /* SPI flash running at full speed */ 66 #define CP500_FLASH_HZ (33 * 1000 * 1000) 67 68 /* LAN9252 */ 69 #define CP500_LAN9252_HZ (10 * 1000 * 1000) 70 71 #define CP500_IS_CP035(dev) ((dev)->pci_dev->device == PCI_DEVICE_ID_KEBA_CP035) 72 #define CP500_IS_CP505(dev) ((dev)->pci_dev->device == PCI_DEVICE_ID_KEBA_CP505) 73 #define CP500_IS_CP520(dev) ((dev)->pci_dev->device == PCI_DEVICE_ID_KEBA_CP520) 74 75 struct cp500_dev_info { 76 off_t offset; 77 size_t size; 78 }; 79 80 struct cp500_devs { 81 struct cp500_dev_info startup; 82 struct cp500_dev_info spi; 83 struct cp500_dev_info i2c; 84 struct cp500_dev_info fan; 85 }; 86 87 /* list of devices within FPGA of CP035 family (CP035, CP056, CP057) */ 88 static struct cp500_devs cp035_devices = { 89 .startup = { 0x0000, SZ_4K }, 90 .spi = { 0x1000, SZ_4K }, 91 .i2c = { 0x4000, SZ_4K }, 92 .fan = { 0x9000, SZ_4K }, 93 }; 94 95 /* list of devices within FPGA of CP505 family (CP503, CP505, CP507) */ 96 static struct cp500_devs cp505_devices = { 97 .startup = { 0x0000, SZ_4K }, 98 .spi = { 0x4000, SZ_4K }, 99 .i2c = { 0x5000, SZ_4K }, 100 .fan = { 0x9000, SZ_4K }, 101 }; 102 103 /* list of devices within FPGA of CP520 family (CP520, CP530) */ 104 static struct cp500_devs cp520_devices = { 105 .startup = { 0x0000, SZ_4K }, 106 .spi = { 0x4000, SZ_4K }, 107 .i2c = { 0x5000, SZ_4K }, 108 .fan = { 0x8000, SZ_4K }, 109 }; 110 111 struct cp500_nvmem { 112 struct nvmem_device *nvmem; 113 unsigned int offset; 114 }; 115 116 struct cp500 { 117 struct pci_dev *pci_dev; 118 struct cp500_devs *devs; 119 int msix_num; 120 struct { 121 int major; 122 int minor; 123 int build; 124 } version; 125 struct notifier_block nvmem_notifier; 126 atomic_t nvmem_notified; 127 128 /* system FPGA BAR */ 129 resource_size_t sys_hwbase; 130 struct keba_spi_auxdev *spi; 131 struct keba_i2c_auxdev *i2c; 132 struct keba_fan_auxdev *fan; 133 134 /* ECM EtherCAT BAR */ 135 resource_size_t ecm_hwbase; 136 137 /* NVMEM devices */ 138 struct cp500_nvmem nvmem_cpu; 139 struct cp500_nvmem nvmem_user; 140 141 void __iomem *system_startup_addr; 142 }; 143 144 /* I2C devices */ 145 #define CP500_EEPROM_ADDR 0x50 146 static struct i2c_board_info cp500_i2c_info[] = { 147 { /* temperature sensor */ 148 I2C_BOARD_INFO("emc1403", 0x4c), 149 }, 150 { /* 151 * CPU EEPROM 152 * CP035 family: CPU board 153 * CP505 family: bridge board 154 * CP520 family: carrier board 155 */ 156 I2C_BOARD_INFO("24c32", CP500_EEPROM_ADDR), 157 }, 158 { /* interface board EEPROM */ 159 I2C_BOARD_INFO("24c32", CP500_EEPROM_ADDR + 1), 160 }, 161 { /* 162 * EEPROM (optional) 163 * CP505 family: CPU board 164 * CP520 family: MMI board 165 */ 166 I2C_BOARD_INFO("24c32", CP500_EEPROM_ADDR + 2), 167 }, 168 { /* extension module 0 EEPROM (optional) */ 169 I2C_BOARD_INFO("24c32", CP500_EEPROM_ADDR + 3), 170 }, 171 { /* extension module 1 EEPROM (optional) */ 172 I2C_BOARD_INFO("24c32", CP500_EEPROM_ADDR + 4), 173 }, 174 { /* extension module 2 EEPROM (optional) */ 175 I2C_BOARD_INFO("24c32", CP500_EEPROM_ADDR + 5), 176 }, 177 { /* extension module 3 EEPROM (optional) */ 178 I2C_BOARD_INFO("24c32", CP500_EEPROM_ADDR + 6), 179 } 180 }; 181 182 /* SPI devices */ 183 static struct mtd_partition cp500_partitions[] = { 184 { 185 .name = "system-flash-parts", 186 .size = MTDPART_SIZ_FULL, 187 .offset = 0, 188 .mask_flags = 0 189 } 190 }; 191 static const struct flash_platform_data cp500_w25q32 = { 192 .type = "w25q32", 193 .name = "system-flash", 194 .parts = cp500_partitions, 195 .nr_parts = ARRAY_SIZE(cp500_partitions), 196 }; 197 static const struct flash_platform_data cp500_m25p16 = { 198 .type = "m25p16", 199 .name = "system-flash", 200 .parts = cp500_partitions, 201 .nr_parts = ARRAY_SIZE(cp500_partitions), 202 }; 203 static struct spi_board_info cp500_spi_info[] = { 204 { /* system FPGA configuration bitstream flash */ 205 .modalias = "m25p80", 206 .platform_data = &cp500_m25p16, 207 .max_speed_hz = CP500_FLASH_HZ, 208 .chip_select = 0, 209 .mode = SPI_MODE_3, 210 }, { /* LAN9252 EtherCAT slave controller */ 211 .modalias = "lan9252", 212 .platform_data = NULL, 213 .max_speed_hz = CP500_LAN9252_HZ, 214 .chip_select = 1, 215 .mode = SPI_MODE_3, 216 } 217 }; 218 219 static ssize_t cp500_get_fpga_version(struct cp500 *cp500, char *buf, 220 size_t max_len) 221 { 222 int n; 223 224 if (CP500_IS_CP035(cp500)) 225 n = scnprintf(buf, max_len, "CP035"); 226 else if (CP500_IS_CP505(cp500)) 227 n = scnprintf(buf, max_len, "CP505"); 228 else 229 n = scnprintf(buf, max_len, "CP500"); 230 231 n += scnprintf(buf + n, max_len - n, "_FPGA_%d.%02d", 232 cp500->version.major, cp500->version.minor); 233 234 /* test versions have test bit set */ 235 if (cp500->version.build & CP500_BUILD_TEST) 236 n += scnprintf(buf + n, max_len - n, "Test%d", 237 cp500->version.build & ~CP500_BUILD_TEST); 238 239 n += scnprintf(buf + n, max_len - n, "\n"); 240 241 return n; 242 } 243 244 static ssize_t version_show(struct device *dev, struct device_attribute *attr, 245 char *buf) 246 { 247 struct cp500 *cp500 = dev_get_drvdata(dev); 248 249 return cp500_get_fpga_version(cp500, buf, PAGE_SIZE); 250 } 251 static DEVICE_ATTR_RO(version); 252 253 static ssize_t keep_cfg_show(struct device *dev, struct device_attribute *attr, 254 char *buf) 255 { 256 struct cp500 *cp500 = dev_get_drvdata(dev); 257 unsigned long keep_cfg = 1; 258 259 /* 260 * FPGA configuration stream is kept during reset when RECONFIG bit is 261 * zero 262 */ 263 if (ioread8(cp500->system_startup_addr + CP500_RECONFIG_REG) & 264 CP500_RECFG_REQ) 265 keep_cfg = 0; 266 267 return sysfs_emit(buf, "%lu\n", keep_cfg); 268 } 269 270 static ssize_t keep_cfg_store(struct device *dev, struct device_attribute *attr, 271 const char *buf, size_t count) 272 { 273 struct cp500 *cp500 = dev_get_drvdata(dev); 274 unsigned long keep_cfg; 275 276 if (kstrtoul(buf, 10, &keep_cfg) < 0) 277 return -EINVAL; 278 279 /* 280 * In normal operation "keep_cfg" is "1". This means that the FPGA keeps 281 * its configuration stream during a reset. 282 * In case of a firmware update of the FPGA, the configuration stream 283 * needs to be reloaded. This can be done without a powercycle by 284 * writing a "0" into the "keep_cfg" attribute. After a reset/reboot th 285 * new configuration stream will be loaded. 286 */ 287 if (keep_cfg) 288 iowrite8(0, cp500->system_startup_addr + CP500_RECONFIG_REG); 289 else 290 iowrite8(CP500_RECFG_REQ, 291 cp500->system_startup_addr + CP500_RECONFIG_REG); 292 293 return count; 294 } 295 static DEVICE_ATTR_RW(keep_cfg); 296 297 static struct attribute *cp500_attrs[] = { 298 &dev_attr_version.attr, 299 &dev_attr_keep_cfg.attr, 300 NULL 301 }; 302 ATTRIBUTE_GROUPS(cp500); 303 304 static void cp500_i2c_release(struct device *dev) 305 { 306 struct keba_i2c_auxdev *i2c = 307 container_of(dev, struct keba_i2c_auxdev, auxdev.dev); 308 309 kfree(i2c); 310 } 311 312 static int cp500_register_i2c(struct cp500 *cp500) 313 { 314 int ret; 315 316 cp500->i2c = kzalloc(sizeof(*cp500->i2c), GFP_KERNEL); 317 if (!cp500->i2c) 318 return -ENOMEM; 319 320 cp500->i2c->auxdev.name = "i2c"; 321 cp500->i2c->auxdev.id = 0; 322 cp500->i2c->auxdev.dev.release = cp500_i2c_release; 323 cp500->i2c->auxdev.dev.parent = &cp500->pci_dev->dev; 324 cp500->i2c->io = (struct resource) { 325 /* I2C register area */ 326 .start = (resource_size_t) cp500->sys_hwbase + 327 cp500->devs->i2c.offset, 328 .end = (resource_size_t) cp500->sys_hwbase + 329 cp500->devs->i2c.offset + 330 cp500->devs->i2c.size - 1, 331 .flags = IORESOURCE_MEM, 332 }; 333 cp500->i2c->info_size = ARRAY_SIZE(cp500_i2c_info); 334 cp500->i2c->info = cp500_i2c_info; 335 336 ret = auxiliary_device_init(&cp500->i2c->auxdev); 337 if (ret) { 338 kfree(cp500->i2c); 339 cp500->i2c = NULL; 340 341 return ret; 342 } 343 ret = __auxiliary_device_add(&cp500->i2c->auxdev, "keba"); 344 if (ret) { 345 auxiliary_device_uninit(&cp500->i2c->auxdev); 346 cp500->i2c = NULL; 347 348 return ret; 349 } 350 351 return 0; 352 } 353 354 static void cp500_spi_release(struct device *dev) 355 { 356 struct keba_spi_auxdev *spi = 357 container_of(dev, struct keba_spi_auxdev, auxdev.dev); 358 359 kfree(spi); 360 } 361 362 static int cp500_register_spi(struct cp500 *cp500, u8 esc_type) 363 { 364 int info_size; 365 int ret; 366 367 cp500->spi = kzalloc(sizeof(*cp500->spi), GFP_KERNEL); 368 if (!cp500->spi) 369 return -ENOMEM; 370 371 if (CP500_IS_CP035(cp500)) 372 cp500_spi_info[0].platform_data = &cp500_w25q32; 373 if (esc_type == CP500_EEPROM_ESC_LAN9252) 374 info_size = ARRAY_SIZE(cp500_spi_info); 375 else 376 info_size = ARRAY_SIZE(cp500_spi_info) - 1; 377 378 cp500->spi->auxdev.name = "spi"; 379 cp500->spi->auxdev.id = 0; 380 cp500->spi->auxdev.dev.release = cp500_spi_release; 381 cp500->spi->auxdev.dev.parent = &cp500->pci_dev->dev; 382 cp500->spi->io = (struct resource) { 383 /* SPI register area */ 384 .start = (resource_size_t) cp500->sys_hwbase + 385 cp500->devs->spi.offset, 386 .end = (resource_size_t) cp500->sys_hwbase + 387 cp500->devs->spi.offset + 388 cp500->devs->spi.size - 1, 389 .flags = IORESOURCE_MEM, 390 }; 391 cp500->spi->info_size = info_size; 392 cp500->spi->info = cp500_spi_info; 393 394 ret = auxiliary_device_init(&cp500->spi->auxdev); 395 if (ret) { 396 kfree(cp500->spi); 397 cp500->spi = NULL; 398 399 return ret; 400 } 401 ret = __auxiliary_device_add(&cp500->spi->auxdev, "keba"); 402 if (ret) { 403 auxiliary_device_uninit(&cp500->spi->auxdev); 404 cp500->spi = NULL; 405 406 return ret; 407 } 408 409 return 0; 410 } 411 412 static void cp500_fan_release(struct device *dev) 413 { 414 struct keba_fan_auxdev *fan = 415 container_of(dev, struct keba_fan_auxdev, auxdev.dev); 416 417 kfree(fan); 418 } 419 420 static int cp500_register_fan(struct cp500 *cp500) 421 { 422 int ret; 423 424 cp500->fan = kzalloc(sizeof(*cp500->fan), GFP_KERNEL); 425 if (!cp500->fan) 426 return -ENOMEM; 427 428 cp500->fan->auxdev.name = "fan"; 429 cp500->fan->auxdev.id = 0; 430 cp500->fan->auxdev.dev.release = cp500_fan_release; 431 cp500->fan->auxdev.dev.parent = &cp500->pci_dev->dev; 432 cp500->fan->io = (struct resource) { 433 /* fan register area */ 434 .start = (resource_size_t) cp500->sys_hwbase + 435 cp500->devs->fan.offset, 436 .end = (resource_size_t) cp500->sys_hwbase + 437 cp500->devs->fan.offset + 438 cp500->devs->fan.size - 1, 439 .flags = IORESOURCE_MEM, 440 }; 441 442 ret = auxiliary_device_init(&cp500->fan->auxdev); 443 if (ret) { 444 kfree(cp500->fan); 445 cp500->fan = NULL; 446 447 return ret; 448 } 449 ret = __auxiliary_device_add(&cp500->fan->auxdev, "keba"); 450 if (ret) { 451 auxiliary_device_uninit(&cp500->fan->auxdev); 452 cp500->fan = NULL; 453 454 return ret; 455 } 456 457 return 0; 458 } 459 460 static int cp500_nvmem_read(void *priv, unsigned int offset, void *val, 461 size_t bytes) 462 { 463 struct cp500_nvmem *nvmem = priv; 464 int ret; 465 466 ret = nvmem_device_read(nvmem->nvmem, nvmem->offset + offset, bytes, 467 val); 468 if (ret != bytes) 469 return ret; 470 471 return 0; 472 } 473 474 static int cp500_nvmem_write(void *priv, unsigned int offset, void *val, 475 size_t bytes) 476 { 477 struct cp500_nvmem *nvmem = priv; 478 int ret; 479 480 ret = nvmem_device_write(nvmem->nvmem, nvmem->offset + offset, bytes, 481 val); 482 if (ret != bytes) 483 return ret; 484 485 return 0; 486 } 487 488 static int cp500_nvmem_register(struct cp500 *cp500, struct nvmem_device *nvmem) 489 { 490 struct device *dev = &cp500->pci_dev->dev; 491 struct nvmem_config nvmem_config = {}; 492 struct nvmem_device *tmp; 493 494 /* 495 * The main EEPROM of CP500 devices is logically split into two EEPROMs. 496 * The first logical EEPROM with 3 kB contains the type label which is 497 * programmed during production of the device. The second logical EEPROM 498 * with 1 kB is not programmed during production and can be used for 499 * arbitrary user data. 500 */ 501 502 nvmem_config.dev = dev; 503 nvmem_config.owner = THIS_MODULE; 504 nvmem_config.id = NVMEM_DEVID_NONE; 505 nvmem_config.type = NVMEM_TYPE_EEPROM; 506 nvmem_config.root_only = true; 507 nvmem_config.reg_read = cp500_nvmem_read; 508 nvmem_config.reg_write = cp500_nvmem_write; 509 510 cp500->nvmem_cpu.nvmem = nvmem; 511 cp500->nvmem_cpu.offset = CP500_EEPROM_CPU_OFFSET; 512 nvmem_config.name = CP500_EEPROM_CPU_NAME; 513 nvmem_config.size = CP500_EEPROM_CPU_SIZE; 514 nvmem_config.priv = &cp500->nvmem_cpu; 515 tmp = devm_nvmem_register(dev, &nvmem_config); 516 if (IS_ERR(tmp)) 517 return PTR_ERR(tmp); 518 519 cp500->nvmem_user.nvmem = nvmem; 520 cp500->nvmem_user.offset = CP500_EEPROM_USER_OFFSET; 521 nvmem_config.name = CP500_EEPROM_USER_NAME; 522 nvmem_config.size = CP500_EEPROM_USER_SIZE; 523 nvmem_config.priv = &cp500->nvmem_user; 524 tmp = devm_nvmem_register(dev, &nvmem_config); 525 if (IS_ERR(tmp)) 526 return PTR_ERR(tmp); 527 528 return 0; 529 } 530 531 static int cp500_nvmem_match(struct device *dev, const void *data) 532 { 533 const struct cp500 *cp500 = data; 534 struct i2c_client *client; 535 536 /* match only CPU EEPROM below the cp500 device */ 537 dev = dev->parent; 538 client = i2c_verify_client(dev); 539 if (!client || client->addr != CP500_EEPROM_ADDR) 540 return 0; 541 while ((dev = dev->parent)) 542 if (dev == &cp500->pci_dev->dev) 543 return 1; 544 545 return 0; 546 } 547 548 static void cp500_devm_nvmem_put(void *data) 549 { 550 struct nvmem_device *nvmem = data; 551 552 nvmem_device_put(nvmem); 553 } 554 555 static int cp500_nvmem(struct notifier_block *nb, unsigned long action, 556 void *data) 557 { 558 struct nvmem_device *nvmem; 559 struct cp500 *cp500; 560 struct device *dev; 561 int notified; 562 u8 esc_type; 563 int ret; 564 565 if (action != NVMEM_ADD) 566 return NOTIFY_DONE; 567 cp500 = container_of(nb, struct cp500, nvmem_notifier); 568 dev = &cp500->pci_dev->dev; 569 570 /* process CPU EEPROM content only once */ 571 notified = atomic_read(&cp500->nvmem_notified); 572 if (notified) 573 return NOTIFY_DONE; 574 nvmem = nvmem_device_find(cp500, cp500_nvmem_match); 575 if (IS_ERR_OR_NULL(nvmem)) 576 return NOTIFY_DONE; 577 if (!atomic_try_cmpxchg_relaxed(&cp500->nvmem_notified, ¬ified, 1)) { 578 nvmem_device_put(nvmem); 579 580 return NOTIFY_DONE; 581 } 582 583 ret = devm_add_action_or_reset(dev, cp500_devm_nvmem_put, nvmem); 584 if (ret) 585 return ret; 586 587 ret = cp500_nvmem_register(cp500, nvmem); 588 if (ret) 589 return ret; 590 591 ret = nvmem_device_read(nvmem, CP500_EEPROM_DA_OFFSET, sizeof(esc_type), 592 (void *)&esc_type); 593 if (ret != sizeof(esc_type)) { 594 dev_warn(dev, "Failed to read device assembly!\n"); 595 596 return NOTIFY_DONE; 597 } 598 esc_type &= CP500_EEPROM_DA_ESC_TYPE_MASK; 599 600 if (cp500_register_spi(cp500, esc_type)) 601 dev_warn(dev, "Failed to register SPI!\n"); 602 603 return NOTIFY_OK; 604 } 605 606 static void cp500_register_auxiliary_devs(struct cp500 *cp500) 607 { 608 struct device *dev = &cp500->pci_dev->dev; 609 u8 present = ioread8(cp500->system_startup_addr + CP500_PRESENT_REG); 610 611 if (cp500_register_i2c(cp500)) 612 dev_warn(dev, "Failed to register I2C!\n"); 613 if (present & CP500_PRESENT_FAN0) 614 if (cp500_register_fan(cp500)) 615 dev_warn(dev, "Failed to register fan!\n"); 616 } 617 618 static void cp500_unregister_dev(struct auxiliary_device *auxdev) 619 { 620 auxiliary_device_delete(auxdev); 621 auxiliary_device_uninit(auxdev); 622 } 623 624 static void cp500_unregister_auxiliary_devs(struct cp500 *cp500) 625 { 626 if (cp500->spi) { 627 cp500_unregister_dev(&cp500->spi->auxdev); 628 cp500->spi = NULL; 629 } 630 if (cp500->i2c) { 631 cp500_unregister_dev(&cp500->i2c->auxdev); 632 cp500->i2c = NULL; 633 } 634 if (cp500->fan) { 635 cp500_unregister_dev(&cp500->fan->auxdev); 636 cp500->fan = NULL; 637 } 638 } 639 640 static irqreturn_t cp500_axi_handler(int irq, void *dev) 641 { 642 struct cp500 *cp500 = dev; 643 u32 axi_address = ioread32(cp500->system_startup_addr + CP500_AXI_REG); 644 645 /* 646 * FPGA signals AXI response error, print AXI address to indicate which 647 * IP core was affected 648 */ 649 dev_err(&cp500->pci_dev->dev, "AXI response error at 0x%08x\n", 650 axi_address); 651 652 return IRQ_HANDLED; 653 } 654 655 static int cp500_enable(struct cp500 *cp500) 656 { 657 int axi_irq = -1; 658 int ret; 659 660 if (cp500->msix_num > CP500_NUM_MSIX_NO_AXI) { 661 axi_irq = pci_irq_vector(cp500->pci_dev, CP500_AXI_MSIX); 662 ret = request_irq(axi_irq, cp500_axi_handler, 0, 663 CP500, cp500); 664 if (ret != 0) { 665 dev_err(&cp500->pci_dev->dev, 666 "Failed to register AXI response error!\n"); 667 return ret; 668 } 669 } 670 671 return 0; 672 } 673 674 static void cp500_disable(struct cp500 *cp500) 675 { 676 int axi_irq; 677 678 if (cp500->msix_num > CP500_NUM_MSIX_NO_AXI) { 679 axi_irq = pci_irq_vector(cp500->pci_dev, CP500_AXI_MSIX); 680 free_irq(axi_irq, cp500); 681 } 682 } 683 684 static int cp500_probe(struct pci_dev *pci_dev, const struct pci_device_id *id) 685 { 686 struct device *dev = &pci_dev->dev; 687 struct resource startup; 688 struct cp500 *cp500; 689 u32 cp500_vers; 690 char buf[64]; 691 int ret; 692 693 cp500 = devm_kzalloc(dev, sizeof(*cp500), GFP_KERNEL); 694 if (!cp500) 695 return -ENOMEM; 696 cp500->pci_dev = pci_dev; 697 cp500->sys_hwbase = pci_resource_start(pci_dev, CP500_SYS_BAR); 698 cp500->ecm_hwbase = pci_resource_start(pci_dev, CP500_ECM_BAR); 699 if (!cp500->sys_hwbase || !cp500->ecm_hwbase) 700 return -ENODEV; 701 702 if (CP500_IS_CP035(cp500)) 703 cp500->devs = &cp035_devices; 704 else if (CP500_IS_CP505(cp500)) 705 cp500->devs = &cp505_devices; 706 else if (CP500_IS_CP520(cp500)) 707 cp500->devs = &cp520_devices; 708 else 709 return -ENODEV; 710 711 ret = pci_enable_device(pci_dev); 712 if (ret) 713 return ret; 714 pci_set_master(pci_dev); 715 716 startup = *pci_resource_n(pci_dev, CP500_SYS_BAR); 717 startup.end = startup.start + cp500->devs->startup.size - 1; 718 cp500->system_startup_addr = devm_ioremap_resource(&pci_dev->dev, 719 &startup); 720 if (IS_ERR(cp500->system_startup_addr)) { 721 ret = PTR_ERR(cp500->system_startup_addr); 722 goto out_disable; 723 } 724 725 cp500->msix_num = pci_alloc_irq_vectors(pci_dev, CP500_NUM_MSIX_NO_MMI, 726 CP500_NUM_MSIX, PCI_IRQ_MSIX); 727 if (cp500->msix_num < CP500_NUM_MSIX_NO_MMI) { 728 dev_err(&pci_dev->dev, 729 "Hardware does not support enough MSI-X interrupts\n"); 730 ret = -ENODEV; 731 goto out_disable; 732 } 733 734 cp500_vers = ioread32(cp500->system_startup_addr + CP500_VERSION_REG); 735 cp500->version.major = (cp500_vers & 0xff); 736 cp500->version.minor = (cp500_vers >> 8) & 0xff; 737 cp500->version.build = (cp500_vers >> 16) & 0xffff; 738 cp500_get_fpga_version(cp500, buf, sizeof(buf)); 739 740 dev_info(&pci_dev->dev, "FPGA version %s", buf); 741 742 pci_set_drvdata(pci_dev, cp500); 743 744 cp500->nvmem_notifier.notifier_call = cp500_nvmem; 745 ret = nvmem_register_notifier(&cp500->nvmem_notifier); 746 if (ret != 0) 747 goto out_free_irq; 748 749 ret = cp500_enable(cp500); 750 if (ret != 0) 751 goto out_unregister_nvmem; 752 753 cp500_register_auxiliary_devs(cp500); 754 755 return 0; 756 757 out_unregister_nvmem: 758 nvmem_unregister_notifier(&cp500->nvmem_notifier); 759 out_free_irq: 760 pci_free_irq_vectors(pci_dev); 761 out_disable: 762 pci_clear_master(pci_dev); 763 pci_disable_device(pci_dev); 764 765 return ret; 766 } 767 768 static void cp500_remove(struct pci_dev *pci_dev) 769 { 770 struct cp500 *cp500 = pci_get_drvdata(pci_dev); 771 772 cp500_unregister_auxiliary_devs(cp500); 773 774 cp500_disable(cp500); 775 776 nvmem_unregister_notifier(&cp500->nvmem_notifier); 777 778 pci_set_drvdata(pci_dev, 0); 779 780 pci_free_irq_vectors(pci_dev); 781 782 pci_clear_master(pci_dev); 783 pci_disable_device(pci_dev); 784 } 785 786 static struct pci_device_id cp500_ids[] = { 787 { PCI_DEVICE(PCI_VENDOR_ID_KEBA, PCI_DEVICE_ID_KEBA_CP035) }, 788 { PCI_DEVICE(PCI_VENDOR_ID_KEBA, PCI_DEVICE_ID_KEBA_CP505) }, 789 { PCI_DEVICE(PCI_VENDOR_ID_KEBA, PCI_DEVICE_ID_KEBA_CP520) }, 790 { } 791 }; 792 MODULE_DEVICE_TABLE(pci, cp500_ids); 793 794 static struct pci_driver cp500_driver = { 795 .name = CP500, 796 .id_table = cp500_ids, 797 .probe = cp500_probe, 798 .remove = cp500_remove, 799 .dev_groups = cp500_groups, 800 }; 801 module_pci_driver(cp500_driver); 802 803 MODULE_AUTHOR("Gerhard Engleder <eg@keba.com>"); 804 MODULE_DESCRIPTION("KEBA CP500 system FPGA driver"); 805 MODULE_LICENSE("GPL"); 806