drivers/pci/controller/pci-ftpci100.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Support for Faraday Technology FTPC100 PCI Controller
   4  *
   5  * Copyright (C) 2017 Linus Walleij <linus.walleij@linaro.org>
   6  *
   7  * Based on the out-of-tree OpenWRT patch for Cortina Gemini:
   8  * Copyright (C) 2009 Janos Laube <janos.dev@gmail.com>
   9  * Copyright (C) 2009 Paulius Zaleckas <paulius.zaleckas@teltonika.lt>
  10  * Based on SL2312 PCI controller code
  11  * Storlink (C) 2003
  12  */
  13
  14 #include <linux/init.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/io.h>
  17 #include <linux/kernel.h>
  18 #include <linux/of.h>
  19 #include <linux/of_irq.h>
  20 #include <linux/of_pci.h>
  21 #include <linux/pci.h>
  22 #include <linux/platform_device.h>
  23 #include <linux/slab.h>
  24 #include <linux/irqdomain.h>
  25 #include <linux/irqchip/chained_irq.h>
  26 #include <linux/bitops.h>
  27 #include <linux/irq.h>
  28 #include <linux/clk.h>
  29
  30 #include "../pci.h"
  31
  32 /*
  33  * Special configuration registers directly in the first few words
  34  * in I/O space.
  35  */
  36 #define FTPCI_IOSIZE    0x00
  37 #define FTPCI_PROT      0x04 /* AHB protection */
  38 #define FTPCI_CTRL      0x08 /* PCI control signal */
  39 #define FTPCI_SOFTRST   0x10 /* Soft reset counter and response error enable */
  40 #define FTPCI_CONFIG    0x28 /* PCI configuration command register */
  41 #define FTPCI_DATA      0x2C
  42
  43 #define FARADAY_PCI_STATUS_CMD          0x04 /* Status and command */
  44 #define FARADAY_PCI_PMC                 0x40 /* Power management control */
  45 #define FARADAY_PCI_PMCSR               0x44 /* Power management status */
  46 #define FARADAY_PCI_CTRL1               0x48 /* Control register 1 */
  47 #define FARADAY_PCI_CTRL2               0x4C /* Control register 2 */
  48 #define FARADAY_PCI_MEM1_BASE_SIZE      0x50 /* Memory base and size #1 */
  49 #define FARADAY_PCI_MEM2_BASE_SIZE      0x54 /* Memory base and size #2 */
  50 #define FARADAY_PCI_MEM3_BASE_SIZE      0x58 /* Memory base and size #3 */
  51
  52 #define PCI_STATUS_66MHZ_CAPABLE        BIT(21)
  53
  54 /* Bits 31..28 gives INTD..INTA status */
  55 #define PCI_CTRL2_INTSTS_SHIFT          28
  56 #define PCI_CTRL2_INTMASK_CMDERR        BIT(27)
  57 #define PCI_CTRL2_INTMASK_PARERR        BIT(26)
  58 /* Bits 25..22 masks INTD..INTA */
  59 #define PCI_CTRL2_INTMASK_SHIFT         22
  60 #define PCI_CTRL2_INTMASK_MABRT_RX      BIT(21)
  61 #define PCI_CTRL2_INTMASK_TABRT_RX      BIT(20)
  62 #define PCI_CTRL2_INTMASK_TABRT_TX      BIT(19)
  63 #define PCI_CTRL2_INTMASK_RETRY4        BIT(18)
  64 #define PCI_CTRL2_INTMASK_SERR_RX       BIT(17)
  65 #define PCI_CTRL2_INTMASK_PERR_RX       BIT(16)
  66 /* Bit 15 reserved */
  67 #define PCI_CTRL2_MSTPRI_REQ6           BIT(14)
  68 #define PCI_CTRL2_MSTPRI_REQ5           BIT(13)
  69 #define PCI_CTRL2_MSTPRI_REQ4           BIT(12)
  70 #define PCI_CTRL2_MSTPRI_REQ3           BIT(11)
  71 #define PCI_CTRL2_MSTPRI_REQ2           BIT(10)
  72 #define PCI_CTRL2_MSTPRI_REQ1           BIT(9)
  73 #define PCI_CTRL2_MSTPRI_REQ0           BIT(8)
  74 /* Bits 7..4 reserved */
  75 /* Bits 3..0 TRDYW */
  76
  77 /*
  78  * Memory configs:
  79  * Bit 31..20 defines the PCI side memory base
  80  * Bit 19..16 (4 bits) defines the size per below
  81  */
  82 #define FARADAY_PCI_MEMBASE_MASK        0xfff00000
  83 #define FARADAY_PCI_MEMSIZE_1MB         0x0
  84 #define FARADAY_PCI_MEMSIZE_2MB         0x1
  85 #define FARADAY_PCI_MEMSIZE_4MB         0x2
  86 #define FARADAY_PCI_MEMSIZE_8MB         0x3
  87 #define FARADAY_PCI_MEMSIZE_16MB        0x4
  88 #define FARADAY_PCI_MEMSIZE_32MB        0x5
  89 #define FARADAY_PCI_MEMSIZE_64MB        0x6
  90 #define FARADAY_PCI_MEMSIZE_128MB       0x7
  91 #define FARADAY_PCI_MEMSIZE_256MB       0x8
  92 #define FARADAY_PCI_MEMSIZE_512MB       0x9
  93 #define FARADAY_PCI_MEMSIZE_1GB         0xa
  94 #define FARADAY_PCI_MEMSIZE_2GB         0xb
  95 #define FARADAY_PCI_MEMSIZE_SHIFT       16
  96
  97 /*
  98  * The DMA base is set to 0x0 for all memory segments, it reflects the
  99  * fact that the memory of the host system starts at 0x0.
 100  */
 101 #define FARADAY_PCI_DMA_MEM1_BASE       0x00000000
 102 #define FARADAY_PCI_DMA_MEM2_BASE       0x00000000
 103 #define FARADAY_PCI_DMA_MEM3_BASE       0x00000000
 104
 105 /**
 106  * struct faraday_pci_variant - encodes IP block differences
 107  * @cascaded_irq: this host has cascaded IRQs from an interrupt controller
 108  *      embedded in the host bridge.
 109  */
 110 struct faraday_pci_variant {
 111         bool cascaded_irq;
 112 };
 113
 114 struct faraday_pci {
 115         struct device *dev;
 116         void __iomem *base;
 117         struct irq_domain *irqdomain;
 118         struct pci_bus *bus;
 119         struct clk *bus_clk;
 120 };
 121
 122 static int faraday_res_to_memcfg(resource_size_t mem_base,
 123                                  resource_size_t mem_size, u32 *val)
 124 {
 125         u32 outval;
 126
 127         switch (mem_size) {
 128         case SZ_1M:
 129                 outval = FARADAY_PCI_MEMSIZE_1MB;
 130                 break;
 131         case SZ_2M:
 132                 outval = FARADAY_PCI_MEMSIZE_2MB;
 133                 break;
 134         case SZ_4M:
 135                 outval = FARADAY_PCI_MEMSIZE_4MB;
 136                 break;
 137         case SZ_8M:
 138                 outval = FARADAY_PCI_MEMSIZE_8MB;
 139                 break;
 140         case SZ_16M:
 141                 outval = FARADAY_PCI_MEMSIZE_16MB;
 142                 break;
 143         case SZ_32M:
 144                 outval = FARADAY_PCI_MEMSIZE_32MB;
 145                 break;
 146         case SZ_64M:
 147                 outval = FARADAY_PCI_MEMSIZE_64MB;
 148                 break;
 149         case SZ_128M:
 150                 outval = FARADAY_PCI_MEMSIZE_128MB;
 151                 break;
 152         case SZ_256M:
 153                 outval = FARADAY_PCI_MEMSIZE_256MB;
 154                 break;
 155         case SZ_512M:
 156                 outval = FARADAY_PCI_MEMSIZE_512MB;
 157                 break;
 158         case SZ_1G:
 159                 outval = FARADAY_PCI_MEMSIZE_1GB;
 160                 break;
 161         case SZ_2G:
 162                 outval = FARADAY_PCI_MEMSIZE_2GB;
 163                 break;
 164         default:
 165                 return -EINVAL;
 166         }
 167         outval <<= FARADAY_PCI_MEMSIZE_SHIFT;
 168
 169         /* This is probably not good */
 170         if (mem_base & ~(FARADAY_PCI_MEMBASE_MASK))
 171                 pr_warn("truncated PCI memory base\n");
 172         /* Translate to bridge side address space */
 173         outval |= (mem_base & FARADAY_PCI_MEMBASE_MASK);
 174         pr_debug("Translated pci base @%pap, size %pap to config %08x\n",
 175                  &mem_base, &mem_size, outval);
 176
 177         *val = outval;
 178         return 0;
 179 }
 180
 181 static int faraday_raw_pci_read_config(struct faraday_pci *p, int bus_number,
 182                                        unsigned int fn, int config, int size,
 183                                        u32 *value)
 184 {
 185         writel(PCI_CONF1_ADDRESS(bus_number, PCI_SLOT(fn),
 186                                  PCI_FUNC(fn), config),
 187                         p->base + FTPCI_CONFIG);
 188
 189         *value = readl(p->base + FTPCI_DATA);
 190
 191         if (size == 1)
 192                 *value = (*value >> (8 * (config & 3))) & 0xFF;
 193         else if (size == 2)
 194                 *value = (*value >> (8 * (config & 3))) & 0xFFFF;
 195
 196         return PCIBIOS_SUCCESSFUL;
 197 }
 198
 199 static int faraday_pci_read_config(struct pci_bus *bus, unsigned int fn,
 200                                    int config, int size, u32 *value)
 201 {
 202         struct faraday_pci *p = bus->sysdata;
 203
 204         dev_dbg(&bus->dev,
 205                 "[read]  slt: %.2d, fnc: %d, cnf: 0x%.2X, val (%d bytes): 0x%.8X\n",
 206                 PCI_SLOT(fn), PCI_FUNC(fn), config, size, *value);
 207
 208         return faraday_raw_pci_read_config(p, bus->number, fn, config, size, value);
 209 }
 210
 211 static int faraday_raw_pci_write_config(struct faraday_pci *p, int bus_number,
 212                                          unsigned int fn, int config, int size,
 213                                          u32 value)
 214 {
 215         int ret = PCIBIOS_SUCCESSFUL;
 216
 217         writel(PCI_CONF1_ADDRESS(bus_number, PCI_SLOT(fn),
 218                                  PCI_FUNC(fn), config),
 219                         p->base + FTPCI_CONFIG);
 220
 221         switch (size) {
 222         case 4:
 223                 writel(value, p->base + FTPCI_DATA);
 224                 break;
 225         case 2:
 226                 writew(value, p->base + FTPCI_DATA + (config & 3));
 227                 break;
 228         case 1:
 229                 writeb(value, p->base + FTPCI_DATA + (config & 3));
 230                 break;
 231         default:
 232                 ret = PCIBIOS_BAD_REGISTER_NUMBER;
 233         }
 234
 235         return ret;
 236 }
 237
 238 static int faraday_pci_write_config(struct pci_bus *bus, unsigned int fn,
 239                                     int config, int size, u32 value)
 240 {
 241         struct faraday_pci *p = bus->sysdata;
 242
 243         dev_dbg(&bus->dev,
 244                 "[write] slt: %.2d, fnc: %d, cnf: 0x%.2X, val (%d bytes): 0x%.8X\n",
 245                 PCI_SLOT(fn), PCI_FUNC(fn), config, size, value);
 246
 247         return faraday_raw_pci_write_config(p, bus->number, fn, config, size,
 248                                             value);
 249 }
 250
 251 static struct pci_ops faraday_pci_ops = {
 252         .read   = faraday_pci_read_config,
 253         .write  = faraday_pci_write_config,
 254 };
 255
 256 static void faraday_pci_ack_irq(struct irq_data *d)
 257 {
 258         struct faraday_pci *p = irq_data_get_irq_chip_data(d);
 259         unsigned int reg;
 260
 261         faraday_raw_pci_read_config(p, 0, 0, FARADAY_PCI_CTRL2, 4, &reg);
 262         reg &= ~(0xF << PCI_CTRL2_INTSTS_SHIFT);
 263         reg |= BIT(irqd_to_hwirq(d) + PCI_CTRL2_INTSTS_SHIFT);
 264         faraday_raw_pci_write_config(p, 0, 0, FARADAY_PCI_CTRL2, 4, reg);
 265 }
 266
 267 static void faraday_pci_mask_irq(struct irq_data *d)
 268 {
 269         struct faraday_pci *p = irq_data_get_irq_chip_data(d);
 270         unsigned int reg;
 271
 272         faraday_raw_pci_read_config(p, 0, 0, FARADAY_PCI_CTRL2, 4, &reg);
 273         reg &= ~((0xF << PCI_CTRL2_INTSTS_SHIFT)
 274                  | BIT(irqd_to_hwirq(d) + PCI_CTRL2_INTMASK_SHIFT));
 275         faraday_raw_pci_write_config(p, 0, 0, FARADAY_PCI_CTRL2, 4, reg);
 276 }
 277
 278 static void faraday_pci_unmask_irq(struct irq_data *d)
 279 {
 280         struct faraday_pci *p = irq_data_get_irq_chip_data(d);
 281         unsigned int reg;
 282
 283         faraday_raw_pci_read_config(p, 0, 0, FARADAY_PCI_CTRL2, 4, &reg);
 284         reg &= ~(0xF << PCI_CTRL2_INTSTS_SHIFT);
 285         reg |= BIT(irqd_to_hwirq(d) + PCI_CTRL2_INTMASK_SHIFT);
 286         faraday_raw_pci_write_config(p, 0, 0, FARADAY_PCI_CTRL2, 4, reg);
 287 }
 288
 289 static void faraday_pci_irq_handler(struct irq_desc *desc)
 290 {
 291         struct faraday_pci *p = irq_desc_get_handler_data(desc);
 292         struct irq_chip *irqchip = irq_desc_get_chip(desc);
 293         unsigned int irq_stat, reg, i;
 294
 295         faraday_raw_pci_read_config(p, 0, 0, FARADAY_PCI_CTRL2, 4, &reg);
 296         irq_stat = reg >> PCI_CTRL2_INTSTS_SHIFT;
 297
 298         chained_irq_enter(irqchip, desc);
 299
 300         for (i = 0; i < 4; i++) {
 301                 if ((irq_stat & BIT(i)) == 0)
 302                         continue;
 303                 generic_handle_domain_irq(p->irqdomain, i);
 304         }
 305
 306         chained_irq_exit(irqchip, desc);
 307 }
 308
 309 static struct irq_chip faraday_pci_irq_chip = {
 310         .name = "PCI",
 311         .irq_ack = faraday_pci_ack_irq,
 312         .irq_mask = faraday_pci_mask_irq,
 313         .irq_unmask = faraday_pci_unmask_irq,
 314 };
 315
 316 static int faraday_pci_irq_map(struct irq_domain *domain, unsigned int irq,
 317                                irq_hw_number_t hwirq)
 318 {
 319         irq_set_chip_and_handler(irq, &faraday_pci_irq_chip, handle_level_irq);
 320         irq_set_chip_data(irq, domain->host_data);
 321
 322         return 0;
 323 }
 324
 325 static const struct irq_domain_ops faraday_pci_irqdomain_ops = {
 326         .map = faraday_pci_irq_map,
 327 };
 328
 329 static int faraday_pci_setup_cascaded_irq(struct faraday_pci *p)
 330 {
 331         struct device_node *intc = of_get_next_child(p->dev->of_node, NULL);
 332         int irq;
 333         int i;
 334
 335         if (!intc) {
 336                 dev_err(p->dev, "missing child interrupt-controller node\n");
 337                 return -EINVAL;
 338         }
 339
 340         /* All PCI IRQs cascade off this one */
 341         irq = of_irq_get(intc, 0);
 342         if (irq <= 0) {
 343                 dev_err(p->dev, "failed to get parent IRQ\n");
 344                 of_node_put(intc);
 345                 return irq ?: -EINVAL;
 346         }
 347
 348         p->irqdomain = irq_domain_add_linear(intc, PCI_NUM_INTX,
 349                                              &faraday_pci_irqdomain_ops, p);
 350         of_node_put(intc);
 351         if (!p->irqdomain) {
 352                 dev_err(p->dev, "failed to create Gemini PCI IRQ domain\n");
 353                 return -EINVAL;
 354         }
 355
 356         irq_set_chained_handler_and_data(irq, faraday_pci_irq_handler, p);
 357
 358         for (i = 0; i < 4; i++)
 359                 irq_create_mapping(p->irqdomain, i);
 360
 361         return 0;
 362 }
 363
 364 static int faraday_pci_parse_map_dma_ranges(struct faraday_pci *p)
 365 {
 366         struct device *dev = p->dev;
 367         struct pci_host_bridge *bridge = pci_host_bridge_from_priv(p);
 368         struct resource_entry *entry;
 369         u32 confreg[3] = {
 370                 FARADAY_PCI_MEM1_BASE_SIZE,
 371                 FARADAY_PCI_MEM2_BASE_SIZE,
 372                 FARADAY_PCI_MEM3_BASE_SIZE,
 373         };
 374         int i = 0;
 375         u32 val;
 376
 377         resource_list_for_each_entry(entry, &bridge->dma_ranges) {
 378                 u64 pci_addr = entry->res->start - entry->offset;
 379                 u64 end = entry->res->end - entry->offset;
 380                 int ret;
 381
 382                 ret = faraday_res_to_memcfg(pci_addr,
 383                                             resource_size(entry->res), &val);
 384                 if (ret) {
 385                         dev_err(dev,
 386                                 "DMA range %d: illegal MEM resource size\n", i);
 387                         return -EINVAL;
 388                 }
 389
 390                 dev_info(dev, "DMA MEM%d BASE: 0x%016llx -> 0x%016llx config %08x\n",
 391                          i + 1, pci_addr, end, val);
 392                 if (i <= 2) {
 393                         faraday_raw_pci_write_config(p, 0, 0, confreg[i],
 394                                                      4, val);
 395                 } else {
 396                         dev_err(dev, "ignore extraneous dma-range %d\n", i);
 397                         break;
 398                 }
 399
 400                 i++;
 401         }
 402
 403         return 0;
 404 }
 405
 406 static int faraday_pci_probe(struct platform_device *pdev)
 407 {
 408         struct device *dev = &pdev->dev;
 409         const struct faraday_pci_variant *variant =
 410                 of_device_get_match_data(dev);
 411         struct resource_entry *win;
 412         struct faraday_pci *p;
 413         struct resource *io;
 414         struct pci_host_bridge *host;
 415         struct clk *clk;
 416         unsigned char max_bus_speed = PCI_SPEED_33MHz;
 417         unsigned char cur_bus_speed = PCI_SPEED_33MHz;
 418         int ret;
 419         u32 val;
 420
 421         host = devm_pci_alloc_host_bridge(dev, sizeof(*p));
 422         if (!host)
 423                 return -ENOMEM;
 424
 425         host->ops = &faraday_pci_ops;
 426         p = pci_host_bridge_priv(host);
 427         host->sysdata = p;
 428         p->dev = dev;
 429
 430         /* Retrieve and enable optional clocks */
 431         clk = devm_clk_get_enabled(dev, "PCLK");
 432         if (IS_ERR(clk))
 433                 return PTR_ERR(clk);
 434         p->bus_clk = devm_clk_get_enabled(dev, "PCICLK");
 435         if (IS_ERR(p->bus_clk))
 436                 return PTR_ERR(p->bus_clk);
 437
 438         p->base = devm_platform_ioremap_resource(pdev, 0);
 439         if (IS_ERR(p->base))
 440                 return PTR_ERR(p->base);
 441
 442         win = resource_list_first_type(&host->windows, IORESOURCE_IO);
 443         if (win) {
 444                 io = win->res;
 445                 if (!faraday_res_to_memcfg(io->start - win->offset,
 446                                            resource_size(io), &val)) {
 447                         /* setup I/O space size */
 448                         writel(val, p->base + FTPCI_IOSIZE);
 449                 } else {
 450                         dev_err(dev, "illegal IO mem size\n");
 451                         return -EINVAL;
 452                 }
 453         }
 454
 455         /* Setup hostbridge */
 456         val = readl(p->base + FTPCI_CTRL);
 457         val |= PCI_COMMAND_IO;
 458         val |= PCI_COMMAND_MEMORY;
 459         val |= PCI_COMMAND_MASTER;
 460         writel(val, p->base + FTPCI_CTRL);
 461         /* Mask and clear all interrupts */
 462         faraday_raw_pci_write_config(p, 0, 0, FARADAY_PCI_CTRL2 + 2, 2, 0xF000);
 463         if (variant->cascaded_irq) {
 464                 ret = faraday_pci_setup_cascaded_irq(p);
 465                 if (ret) {
 466                         dev_err(dev, "failed to setup cascaded IRQ\n");
 467                         return ret;
 468                 }
 469         }
 470
 471         /* Check bus clock if we can gear up to 66 MHz */
 472         if (!IS_ERR(p->bus_clk)) {
 473                 unsigned long rate;
 474                 u32 val;
 475
 476                 faraday_raw_pci_read_config(p, 0, 0,
 477                                             FARADAY_PCI_STATUS_CMD, 4, &val);
 478                 rate = clk_get_rate(p->bus_clk);
 479
 480                 if ((rate == 33000000) && (val & PCI_STATUS_66MHZ_CAPABLE)) {
 481                         dev_info(dev, "33MHz bus is 66MHz capable\n");
 482                         max_bus_speed = PCI_SPEED_66MHz;
 483                         ret = clk_set_rate(p->bus_clk, 66000000);
 484                         if (ret)
 485                                 dev_err(dev, "failed to set bus clock\n");
 486                 } else {
 487                         dev_info(dev, "33MHz only bus\n");
 488                         max_bus_speed = PCI_SPEED_33MHz;
 489                 }
 490
 491                 /* Bumping the clock may fail so read back the rate */
 492                 rate = clk_get_rate(p->bus_clk);
 493                 if (rate == 33000000)
 494                         cur_bus_speed = PCI_SPEED_33MHz;
 495                 if (rate == 66000000)
 496                         cur_bus_speed = PCI_SPEED_66MHz;
 497         }
 498
 499         ret = faraday_pci_parse_map_dma_ranges(p);
 500         if (ret)
 501                 return ret;
 502
 503         ret = pci_scan_root_bus_bridge(host);
 504         if (ret) {
 505                 dev_err(dev, "failed to scan host: %d\n", ret);
 506                 return ret;
 507         }
 508         p->bus = host->bus;
 509         p->bus->max_bus_speed = max_bus_speed;
 510         p->bus->cur_bus_speed = cur_bus_speed;
 511
 512         pci_bus_assign_resources(p->bus);
 513         pci_bus_add_devices(p->bus);
 514
 515         return 0;
 516 }
 517
 518 /*
 519  * We encode bridge variants here, we have at least two so it doesn't
 520  * hurt to have infrastructure to encompass future variants as well.
 521  */
 522 static const struct faraday_pci_variant faraday_regular = {
 523         .cascaded_irq = true,
 524 };
 525
 526 static const struct faraday_pci_variant faraday_dual = {
 527         .cascaded_irq = false,
 528 };
 529
 530 static const struct of_device_id faraday_pci_of_match[] = {
 531         {
 532                 .compatible = "faraday,ftpci100",
 533                 .data = &faraday_regular,
 534         },
 535         {
 536                 .compatible = "faraday,ftpci100-dual",
 537                 .data = &faraday_dual,
 538         },
 539         {},
 540 };
 541
 542 static struct platform_driver faraday_pci_driver = {
 543         .driver = {
 544                 .name = "ftpci100",
 545                 .of_match_table = faraday_pci_of_match,
 546                 .suppress_bind_attrs = true,
 547         },
 548         .probe  = faraday_pci_probe,
 549 };
 550 builtin_platform_driver(faraday_pci_driver);