drivers/misc/keba/cp500.c

   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/pci.h>
  16
  17 #define CP500 "cp500"
  18
  19 #define PCI_VENDOR_ID_KEBA              0xCEBA
  20 #define PCI_DEVICE_ID_KEBA_CP035        0x2706
  21 #define PCI_DEVICE_ID_KEBA_CP505        0x2703
  22 #define PCI_DEVICE_ID_KEBA_CP520        0x2696
  23
  24 #define CP500_SYS_BAR           0
  25 #define CP500_ECM_BAR           1
  26
  27 /* BAR 0 registers */
  28 #define CP500_VERSION_REG       0x00
  29 #define CP500_RECONFIG_REG      0x11    /* upper 8-bits of STARTUP register */
  30 #define CP500_AXI_REG           0x40
  31
  32 /* Bits in BUILD_REG */
  33 #define CP500_BUILD_TEST        0x8000  /* FPGA test version */
  34
  35 /* Bits in RECONFIG_REG */
  36 #define CP500_RECFG_REQ         0x01    /* reconfigure FPGA on next reset */
  37
  38 /* MSIX */
  39 #define CP500_AXI_MSIX          3
  40 #define CP500_NUM_MSIX          8
  41 #define CP500_NUM_MSIX_NO_MMI   2
  42 #define CP500_NUM_MSIX_NO_AXI   3
  43
  44 /* EEPROM */
  45 #define CP500_HW_CPU_EEPROM_NAME        "cp500_cpu_eeprom"
  46
  47 #define CP500_IS_CP035(dev)     ((dev)->pci_dev->device == PCI_DEVICE_ID_KEBA_CP035)
  48 #define CP500_IS_CP505(dev)     ((dev)->pci_dev->device == PCI_DEVICE_ID_KEBA_CP505)
  49 #define CP500_IS_CP520(dev)     ((dev)->pci_dev->device == PCI_DEVICE_ID_KEBA_CP520)
  50
  51 struct cp500_dev_info {
  52         off_t offset;
  53         size_t size;
  54 };
  55
  56 struct cp500_devs {
  57         struct cp500_dev_info startup;
  58         struct cp500_dev_info i2c;
  59 };
  60
  61 /* list of devices within FPGA of CP035 family (CP035, CP056, CP057) */
  62 static struct cp500_devs cp035_devices = {
  63         .startup   = { 0x0000, SZ_4K },
  64         .i2c       = { 0x4000, SZ_4K },
  65 };
  66
  67 /* list of devices within FPGA of CP505 family (CP503, CP505, CP507) */
  68 static struct cp500_devs cp505_devices = {
  69         .startup   = { 0x0000, SZ_4K },
  70         .i2c       = { 0x5000, SZ_4K },
  71 };
  72
  73 /* list of devices within FPGA of CP520 family (CP520, CP530) */
  74 static struct cp500_devs cp520_devices = {
  75         .startup     = { 0x0000, SZ_4K },
  76         .i2c         = { 0x5000, SZ_4K },
  77 };
  78
  79 struct cp500 {
  80         struct pci_dev *pci_dev;
  81         struct cp500_devs *devs;
  82         int msix_num;
  83         struct {
  84                 int major;
  85                 int minor;
  86                 int build;
  87         } version;
  88
  89         /* system FPGA BAR */
  90         resource_size_t sys_hwbase;
  91         struct keba_i2c_auxdev *i2c;
  92
  93         /* ECM EtherCAT BAR */
  94         resource_size_t ecm_hwbase;
  95
  96         void __iomem *system_startup_addr;
  97 };
  98
  99 /* I2C devices */
 100 static struct i2c_board_info cp500_i2c_info[] = {
 101         {       /* temperature sensor */
 102                 I2C_BOARD_INFO("emc1403", 0x4c),
 103         },
 104         {       /*
 105                  * CPU EEPROM
 106                  * CP035 family: CPU board
 107                  * CP505 family: bridge board
 108                  * CP520 family: carrier board
 109                  */
 110                 I2C_BOARD_INFO("24c32", 0x50),
 111                 .dev_name = CP500_HW_CPU_EEPROM_NAME,
 112         },
 113         {       /* interface board EEPROM */
 114                 I2C_BOARD_INFO("24c32", 0x51),
 115         },
 116         {       /*
 117                  * EEPROM (optional)
 118                  * CP505 family: CPU board
 119                  * CP520 family: MMI board
 120                  */
 121                 I2C_BOARD_INFO("24c32", 0x52),
 122         },
 123         {       /* extension module 0 EEPROM (optional) */
 124                 I2C_BOARD_INFO("24c32", 0x53),
 125         },
 126         {       /* extension module 1 EEPROM (optional) */
 127                 I2C_BOARD_INFO("24c32", 0x54),
 128         },
 129         {       /* extension module 2 EEPROM (optional) */
 130                 I2C_BOARD_INFO("24c32", 0x55),
 131         },
 132         {       /* extension module 3 EEPROM (optional) */
 133                 I2C_BOARD_INFO("24c32", 0x56),
 134         }
 135 };
 136
 137 static ssize_t cp500_get_fpga_version(struct cp500 *cp500, char *buf,
 138                                       size_t max_len)
 139 {
 140         int n;
 141
 142         if (CP500_IS_CP035(cp500))
 143                 n = scnprintf(buf, max_len, "CP035");
 144         else if (CP500_IS_CP505(cp500))
 145                 n = scnprintf(buf, max_len, "CP505");
 146         else
 147                 n = scnprintf(buf, max_len, "CP500");
 148
 149         n += scnprintf(buf + n, max_len - n, "_FPGA_%d.%02d",
 150                        cp500->version.major, cp500->version.minor);
 151
 152         /* test versions have test bit set */
 153         if (cp500->version.build & CP500_BUILD_TEST)
 154                 n += scnprintf(buf + n, max_len - n, "Test%d",
 155                                cp500->version.build & ~CP500_BUILD_TEST);
 156
 157         n += scnprintf(buf + n, max_len - n, "\n");
 158
 159         return n;
 160 }
 161
 162 static ssize_t version_show(struct device *dev, struct device_attribute *attr,
 163                             char *buf)
 164 {
 165         struct cp500 *cp500 = dev_get_drvdata(dev);
 166
 167         return cp500_get_fpga_version(cp500, buf, PAGE_SIZE);
 168 }
 169 static DEVICE_ATTR_RO(version);
 170
 171 static ssize_t keep_cfg_show(struct device *dev, struct device_attribute *attr,
 172                              char *buf)
 173 {
 174         struct cp500 *cp500 = dev_get_drvdata(dev);
 175         unsigned long keep_cfg = 1;
 176
 177         /*
 178          * FPGA configuration stream is kept during reset when RECONFIG bit is
 179          * zero
 180          */
 181         if (ioread8(cp500->system_startup_addr + CP500_RECONFIG_REG) &
 182                 CP500_RECFG_REQ)
 183                 keep_cfg = 0;
 184
 185         return sysfs_emit(buf, "%lu\n", keep_cfg);
 186 }
 187
 188 static ssize_t keep_cfg_store(struct device *dev, struct device_attribute *attr,
 189                               const char *buf, size_t count)
 190 {
 191         struct cp500 *cp500 = dev_get_drvdata(dev);
 192         unsigned long keep_cfg;
 193
 194         if (kstrtoul(buf, 10, &keep_cfg) < 0)
 195                 return -EINVAL;
 196
 197         /*
 198          * In normal operation "keep_cfg" is "1". This means that the FPGA keeps
 199          * its configuration stream during a reset.
 200          * In case of a firmware update of the FPGA, the configuration stream
 201          * needs to be reloaded. This can be done without a powercycle by
 202          * writing a "0" into the "keep_cfg" attribute. After a reset/reboot th
 203          * new configuration stream will be loaded.
 204          */
 205         if (keep_cfg)
 206                 iowrite8(0, cp500->system_startup_addr + CP500_RECONFIG_REG);
 207         else
 208                 iowrite8(CP500_RECFG_REQ,
 209                          cp500->system_startup_addr + CP500_RECONFIG_REG);
 210
 211         return count;
 212 }
 213 static DEVICE_ATTR_RW(keep_cfg);
 214
 215 static struct attribute *attrs[] = {
 216         &dev_attr_version.attr,
 217         &dev_attr_keep_cfg.attr,
 218         NULL
 219 };
 220 static const struct attribute_group attrs_group = { .attrs = attrs };
 221
 222 static void cp500_i2c_release(struct device *dev)
 223 {
 224         struct keba_i2c_auxdev *i2c =
 225                 container_of(dev, struct keba_i2c_auxdev, auxdev.dev);
 226
 227         kfree(i2c);
 228 }
 229
 230 static int cp500_register_i2c(struct cp500 *cp500)
 231 {
 232         int retval;
 233
 234         cp500->i2c = kzalloc(sizeof(*cp500->i2c), GFP_KERNEL);
 235         if (!cp500->i2c)
 236                 return -ENOMEM;
 237
 238         cp500->i2c->auxdev.name = "i2c";
 239         cp500->i2c->auxdev.id = 0;
 240         cp500->i2c->auxdev.dev.release = cp500_i2c_release;
 241         cp500->i2c->auxdev.dev.parent = &cp500->pci_dev->dev;
 242         cp500->i2c->io = (struct resource) {
 243                  /* I2C register area */
 244                  .start = (resource_size_t) cp500->sys_hwbase +
 245                           cp500->devs->i2c.offset,
 246                  .end   = (resource_size_t) cp500->sys_hwbase +
 247                           cp500->devs->i2c.offset +
 248                           cp500->devs->i2c.size - 1,
 249                  .flags = IORESOURCE_MEM,
 250         };
 251         cp500->i2c->info_size = ARRAY_SIZE(cp500_i2c_info);
 252         cp500->i2c->info = cp500_i2c_info;
 253
 254         retval = auxiliary_device_init(&cp500->i2c->auxdev);
 255         if (retval) {
 256                 kfree(cp500->i2c);
 257                 cp500->i2c = NULL;
 258
 259                 return retval;
 260         }
 261         retval = __auxiliary_device_add(&cp500->i2c->auxdev, "keba");
 262         if (retval) {
 263                 auxiliary_device_uninit(&cp500->i2c->auxdev);
 264                 cp500->i2c = NULL;
 265
 266                 return retval;
 267         }
 268
 269         return 0;
 270 }
 271
 272 static void cp500_register_auxiliary_devs(struct cp500 *cp500)
 273 {
 274         struct device *dev = &cp500->pci_dev->dev;
 275
 276         if (cp500_register_i2c(cp500))
 277                 dev_warn(dev, "Failed to register i2c!\n");
 278 }
 279
 280 static void cp500_unregister_dev(struct auxiliary_device *auxdev)
 281 {
 282         auxiliary_device_delete(auxdev);
 283         auxiliary_device_uninit(auxdev);
 284 }
 285
 286 static void cp500_unregister_auxiliary_devs(struct cp500 *cp500)
 287 {
 288
 289         if (cp500->i2c) {
 290                 cp500_unregister_dev(&cp500->i2c->auxdev);
 291                 cp500->i2c = NULL;
 292         }
 293 }
 294
 295 static irqreturn_t cp500_axi_handler(int irq, void *dev)
 296 {
 297         struct cp500 *cp500 = dev;
 298         u32 axi_address = ioread32(cp500->system_startup_addr + CP500_AXI_REG);
 299
 300         /*
 301          * FPGA signals AXI response error, print AXI address to indicate which
 302          * IP core was affected
 303          */
 304         dev_err(&cp500->pci_dev->dev, "AXI response error at 0x%08x\n",
 305                 axi_address);
 306
 307         return IRQ_HANDLED;
 308 }
 309
 310 static int cp500_enable(struct cp500 *cp500)
 311 {
 312         int axi_irq = -1;
 313         int ret;
 314
 315         if (cp500->msix_num > CP500_NUM_MSIX_NO_AXI) {
 316                 axi_irq = pci_irq_vector(cp500->pci_dev, CP500_AXI_MSIX);
 317                 ret = request_irq(axi_irq, cp500_axi_handler, 0,
 318                                   CP500, cp500);
 319                 if (ret != 0) {
 320                         dev_err(&cp500->pci_dev->dev,
 321                                 "Failed to register AXI response error!\n");
 322                         return ret;
 323                 }
 324         }
 325
 326         return 0;
 327 }
 328
 329 static void cp500_disable(struct cp500 *cp500)
 330 {
 331         int axi_irq;
 332
 333         if (cp500->msix_num > CP500_NUM_MSIX_NO_AXI) {
 334                 axi_irq = pci_irq_vector(cp500->pci_dev, CP500_AXI_MSIX);
 335                 free_irq(axi_irq, cp500);
 336         }
 337 }
 338
 339 static int cp500_probe(struct pci_dev *pci_dev, const struct pci_device_id *id)
 340 {
 341         struct device *dev = &pci_dev->dev;
 342         struct resource startup;
 343         struct cp500 *cp500;
 344         u32 cp500_vers;
 345         char buf[64];
 346         int ret;
 347
 348         cp500 = devm_kzalloc(dev, sizeof(*cp500), GFP_KERNEL);
 349         if (!cp500)
 350                 return -ENOMEM;
 351         cp500->pci_dev = pci_dev;
 352         cp500->sys_hwbase = pci_resource_start(pci_dev, CP500_SYS_BAR);
 353         cp500->ecm_hwbase = pci_resource_start(pci_dev, CP500_ECM_BAR);
 354         if (!cp500->sys_hwbase || !cp500->ecm_hwbase)
 355                 return -ENODEV;
 356
 357         if (CP500_IS_CP035(cp500))
 358                 cp500->devs = &cp035_devices;
 359         else if (CP500_IS_CP505(cp500))
 360                 cp500->devs = &cp505_devices;
 361         else if (CP500_IS_CP520(cp500))
 362                 cp500->devs = &cp520_devices;
 363         else
 364                 return -ENODEV;
 365
 366         ret = pci_enable_device(pci_dev);
 367         if (ret)
 368                 return ret;
 369         pci_set_master(pci_dev);
 370
 371         startup = *pci_resource_n(pci_dev, CP500_SYS_BAR);
 372         startup.end = startup.start + cp500->devs->startup.size - 1;
 373         cp500->system_startup_addr = devm_ioremap_resource(&pci_dev->dev,
 374                                                            &startup);
 375         if (IS_ERR(cp500->system_startup_addr)) {
 376                 ret = PTR_ERR(cp500->system_startup_addr);
 377                 goto out_disable;
 378         }
 379
 380         cp500->msix_num = pci_alloc_irq_vectors(pci_dev, CP500_NUM_MSIX_NO_MMI,
 381                                                 CP500_NUM_MSIX, PCI_IRQ_MSIX);
 382         if (cp500->msix_num < CP500_NUM_MSIX_NO_MMI) {
 383                 dev_err(&pci_dev->dev,
 384                         "Hardware does not support enough MSI-X interrupts\n");
 385                 ret = -ENODEV;
 386                 goto out_disable;
 387         }
 388
 389         cp500_vers = ioread32(cp500->system_startup_addr + CP500_VERSION_REG);
 390         cp500->version.major = (cp500_vers & 0xff);
 391         cp500->version.minor = (cp500_vers >> 8) & 0xff;
 392         cp500->version.build = (cp500_vers >> 16) & 0xffff;
 393         cp500_get_fpga_version(cp500, buf, sizeof(buf));
 394
 395         dev_info(&pci_dev->dev, "FPGA version %s", buf);
 396
 397         pci_set_drvdata(pci_dev, cp500);
 398
 399         ret = sysfs_create_group(&pci_dev->dev.kobj, &attrs_group);
 400         if (ret != 0)
 401                 goto out_free_irq;
 402
 403         ret = cp500_enable(cp500);
 404         if (ret != 0)
 405                 goto out_remove_group;
 406
 407         cp500_register_auxiliary_devs(cp500);
 408
 409         return 0;
 410
 411 out_remove_group:
 412         sysfs_remove_group(&pci_dev->dev.kobj, &attrs_group);
 413 out_free_irq:
 414         pci_free_irq_vectors(pci_dev);
 415 out_disable:
 416         pci_clear_master(pci_dev);
 417         pci_disable_device(pci_dev);
 418
 419         return ret;
 420 }
 421
 422 static void cp500_remove(struct pci_dev *pci_dev)
 423 {
 424         struct cp500 *cp500 = pci_get_drvdata(pci_dev);
 425
 426         cp500_unregister_auxiliary_devs(cp500);
 427
 428         cp500_disable(cp500);
 429
 430         sysfs_remove_group(&pci_dev->dev.kobj, &attrs_group);
 431
 432         pci_set_drvdata(pci_dev, 0);
 433
 434         pci_free_irq_vectors(pci_dev);
 435
 436         pci_clear_master(pci_dev);
 437         pci_disable_device(pci_dev);
 438 }
 439
 440 static struct pci_device_id cp500_ids[] = {
 441         { PCI_DEVICE(PCI_VENDOR_ID_KEBA, PCI_DEVICE_ID_KEBA_CP035) },
 442         { PCI_DEVICE(PCI_VENDOR_ID_KEBA, PCI_DEVICE_ID_KEBA_CP505) },
 443         { PCI_DEVICE(PCI_VENDOR_ID_KEBA, PCI_DEVICE_ID_KEBA_CP520) },
 444         { }
 445 };
 446 MODULE_DEVICE_TABLE(pci, cp500_ids);
 447
 448 static struct pci_driver cp500_driver = {
 449         .name = CP500,
 450         .id_table = cp500_ids,
 451         .probe = cp500_probe,
 452         .remove = cp500_remove,
 453 };
 454 module_pci_driver(cp500_driver);
 455
 456 MODULE_AUTHOR("Gerhard Engleder <[email protected]>");
 457 MODULE_DESCRIPTION("KEBA CP500 system FPGA driver");
 458 MODULE_LICENSE("GPL");