linux/arch/powerpc/platforms/pseries/msi.c
<<
>>
Prefs
   1/*
   2 * Copyright 2006 Jake Moilanen <moilanen@austin.ibm.com>, IBM Corp.
   3 * Copyright 2006-2007 Michael Ellerman, IBM Corp.
   4 *
   5 * This program is free software; you can redistribute it and/or
   6 * modify it under the terms of the GNU General Public License
   7 * as published by the Free Software Foundation; version 2 of the
   8 * License.
   9 *
  10 */
  11
  12#include <linux/device.h>
  13#include <linux/irq.h>
  14#include <linux/msi.h>
  15
  16#include <asm/rtas.h>
  17#include <asm/hw_irq.h>
  18#include <asm/ppc-pci.h>
  19#include <asm/machdep.h>
  20
  21#include "pseries.h"
  22
  23static int query_token, change_token;
  24
  25#define RTAS_QUERY_FN           0
  26#define RTAS_CHANGE_FN          1
  27#define RTAS_RESET_FN           2
  28#define RTAS_CHANGE_MSI_FN      3
  29#define RTAS_CHANGE_MSIX_FN     4
  30#define RTAS_CHANGE_32MSI_FN    5
  31
  32/* RTAS Helpers */
  33
  34static int rtas_change_msi(struct pci_dn *pdn, u32 func, u32 num_irqs)
  35{
  36        u32 addr, seq_num, rtas_ret[3];
  37        unsigned long buid;
  38        int rc;
  39
  40        addr = rtas_config_addr(pdn->busno, pdn->devfn, 0);
  41        buid = pdn->phb->buid;
  42
  43        seq_num = 1;
  44        do {
  45                if (func == RTAS_CHANGE_MSI_FN || func == RTAS_CHANGE_MSIX_FN ||
  46                    func == RTAS_CHANGE_32MSI_FN)
  47                        rc = rtas_call(change_token, 6, 4, rtas_ret, addr,
  48                                        BUID_HI(buid), BUID_LO(buid),
  49                                        func, num_irqs, seq_num);
  50                else
  51                        rc = rtas_call(change_token, 6, 3, rtas_ret, addr,
  52                                        BUID_HI(buid), BUID_LO(buid),
  53                                        func, num_irqs, seq_num);
  54
  55                seq_num = rtas_ret[1];
  56        } while (rtas_busy_delay(rc));
  57
  58        /*
  59         * If the RTAS call succeeded, return the number of irqs allocated.
  60         * If not, make sure we return a negative error code.
  61         */
  62        if (rc == 0)
  63                rc = rtas_ret[0];
  64        else if (rc > 0)
  65                rc = -rc;
  66
  67        pr_debug("rtas_msi: ibm,change_msi(func=%d,num=%d), got %d rc = %d\n",
  68                 func, num_irqs, rtas_ret[0], rc);
  69
  70        return rc;
  71}
  72
  73static void rtas_disable_msi(struct pci_dev *pdev)
  74{
  75        struct pci_dn *pdn;
  76
  77        pdn = pci_get_pdn(pdev);
  78        if (!pdn)
  79                return;
  80
  81        /*
  82         * disabling MSI with the explicit interface also disables MSI-X
  83         */
  84        if (rtas_change_msi(pdn, RTAS_CHANGE_MSI_FN, 0) != 0) {
  85                /* 
  86                 * may have failed because explicit interface is not
  87                 * present
  88                 */
  89                if (rtas_change_msi(pdn, RTAS_CHANGE_FN, 0) != 0) {
  90                        pr_debug("rtas_msi: Setting MSIs to 0 failed!\n");
  91                }
  92        }
  93}
  94
  95static int rtas_query_irq_number(struct pci_dn *pdn, int offset)
  96{
  97        u32 addr, rtas_ret[2];
  98        unsigned long buid;
  99        int rc;
 100
 101        addr = rtas_config_addr(pdn->busno, pdn->devfn, 0);
 102        buid = pdn->phb->buid;
 103
 104        do {
 105                rc = rtas_call(query_token, 4, 3, rtas_ret, addr,
 106                               BUID_HI(buid), BUID_LO(buid), offset);
 107        } while (rtas_busy_delay(rc));
 108
 109        if (rc) {
 110                pr_debug("rtas_msi: error (%d) querying source number\n", rc);
 111                return rc;
 112        }
 113
 114        return rtas_ret[0];
 115}
 116
 117static void rtas_teardown_msi_irqs(struct pci_dev *pdev)
 118{
 119        struct msi_desc *entry;
 120
 121        for_each_pci_msi_entry(entry, pdev) {
 122                if (!entry->irq)
 123                        continue;
 124
 125                irq_set_msi_desc(entry->irq, NULL);
 126                irq_dispose_mapping(entry->irq);
 127        }
 128
 129        rtas_disable_msi(pdev);
 130}
 131
 132static int check_req(struct pci_dev *pdev, int nvec, char *prop_name)
 133{
 134        struct device_node *dn;
 135        struct pci_dn *pdn;
 136        const __be32 *p;
 137        u32 req_msi;
 138
 139        pdn = pci_get_pdn(pdev);
 140        if (!pdn)
 141                return -ENODEV;
 142
 143        dn = pdn->node;
 144
 145        p = of_get_property(dn, prop_name, NULL);
 146        if (!p) {
 147                pr_debug("rtas_msi: No %s on %s\n", prop_name, dn->full_name);
 148                return -ENOENT;
 149        }
 150
 151        req_msi = be32_to_cpup(p);
 152        if (req_msi < nvec) {
 153                pr_debug("rtas_msi: %s requests < %d MSIs\n", prop_name, nvec);
 154
 155                if (req_msi == 0) /* Be paranoid */
 156                        return -ENOSPC;
 157
 158                return req_msi;
 159        }
 160
 161        return 0;
 162}
 163
 164static int check_req_msi(struct pci_dev *pdev, int nvec)
 165{
 166        return check_req(pdev, nvec, "ibm,req#msi");
 167}
 168
 169static int check_req_msix(struct pci_dev *pdev, int nvec)
 170{
 171        return check_req(pdev, nvec, "ibm,req#msi-x");
 172}
 173
 174/* Quota calculation */
 175
 176static struct device_node *find_pe_total_msi(struct pci_dev *dev, int *total)
 177{
 178        struct device_node *dn;
 179        const __be32 *p;
 180
 181        dn = of_node_get(pci_device_to_OF_node(dev));
 182        while (dn) {
 183                p = of_get_property(dn, "ibm,pe-total-#msi", NULL);
 184                if (p) {
 185                        pr_debug("rtas_msi: found prop on dn %s\n",
 186                                dn->full_name);
 187                        *total = be32_to_cpup(p);
 188                        return dn;
 189                }
 190
 191                dn = of_get_next_parent(dn);
 192        }
 193
 194        return NULL;
 195}
 196
 197static struct device_node *find_pe_dn(struct pci_dev *dev, int *total)
 198{
 199        struct device_node *dn;
 200        struct pci_dn *pdn;
 201        struct eeh_dev *edev;
 202
 203        /* Found our PE and assume 8 at that point. */
 204
 205        dn = pci_device_to_OF_node(dev);
 206        if (!dn)
 207                return NULL;
 208
 209        /* Get the top level device in the PE */
 210        edev = pdn_to_eeh_dev(PCI_DN(dn));
 211        if (edev->pe)
 212                edev = list_first_entry(&edev->pe->edevs, struct eeh_dev, list);
 213        pdn = eeh_dev_to_pdn(edev);
 214        dn = pdn ? pdn->node : NULL;
 215        if (!dn)
 216                return NULL;
 217
 218        /* We actually want the parent */
 219        dn = of_get_parent(dn);
 220        if (!dn)
 221                return NULL;
 222
 223        /* Hardcode of 8 for old firmwares */
 224        *total = 8;
 225        pr_debug("rtas_msi: using PE dn %s\n", dn->full_name);
 226
 227        return dn;
 228}
 229
 230struct msi_counts {
 231        struct device_node *requestor;
 232        int num_devices;
 233        int request;
 234        int quota;
 235        int spare;
 236        int over_quota;
 237};
 238
 239static void *count_non_bridge_devices(struct device_node *dn, void *data)
 240{
 241        struct msi_counts *counts = data;
 242        const __be32 *p;
 243        u32 class;
 244
 245        pr_debug("rtas_msi: counting %s\n", dn->full_name);
 246
 247        p = of_get_property(dn, "class-code", NULL);
 248        class = p ? be32_to_cpup(p) : 0;
 249
 250        if ((class >> 8) != PCI_CLASS_BRIDGE_PCI)
 251                counts->num_devices++;
 252
 253        return NULL;
 254}
 255
 256static void *count_spare_msis(struct device_node *dn, void *data)
 257{
 258        struct msi_counts *counts = data;
 259        const __be32 *p;
 260        int req;
 261
 262        if (dn == counts->requestor)
 263                req = counts->request;
 264        else {
 265                /* We don't know if a driver will try to use MSI or MSI-X,
 266                 * so we just have to punt and use the larger of the two. */
 267                req = 0;
 268                p = of_get_property(dn, "ibm,req#msi", NULL);
 269                if (p)
 270                        req = be32_to_cpup(p);
 271
 272                p = of_get_property(dn, "ibm,req#msi-x", NULL);
 273                if (p)
 274                        req = max(req, (int)be32_to_cpup(p));
 275        }
 276
 277        if (req < counts->quota)
 278                counts->spare += counts->quota - req;
 279        else if (req > counts->quota)
 280                counts->over_quota++;
 281
 282        return NULL;
 283}
 284
 285static int msi_quota_for_device(struct pci_dev *dev, int request)
 286{
 287        struct device_node *pe_dn;
 288        struct msi_counts counts;
 289        int total;
 290
 291        pr_debug("rtas_msi: calc quota for %s, request %d\n", pci_name(dev),
 292                  request);
 293
 294        pe_dn = find_pe_total_msi(dev, &total);
 295        if (!pe_dn)
 296                pe_dn = find_pe_dn(dev, &total);
 297
 298        if (!pe_dn) {
 299                pr_err("rtas_msi: couldn't find PE for %s\n", pci_name(dev));
 300                goto out;
 301        }
 302
 303        pr_debug("rtas_msi: found PE %s\n", pe_dn->full_name);
 304
 305        memset(&counts, 0, sizeof(struct msi_counts));
 306
 307        /* Work out how many devices we have below this PE */
 308        pci_traverse_device_nodes(pe_dn, count_non_bridge_devices, &counts);
 309
 310        if (counts.num_devices == 0) {
 311                pr_err("rtas_msi: found 0 devices under PE for %s\n",
 312                        pci_name(dev));
 313                goto out;
 314        }
 315
 316        counts.quota = total / counts.num_devices;
 317        if (request <= counts.quota)
 318                goto out;
 319
 320        /* else, we have some more calculating to do */
 321        counts.requestor = pci_device_to_OF_node(dev);
 322        counts.request = request;
 323        pci_traverse_device_nodes(pe_dn, count_spare_msis, &counts);
 324
 325        /* If the quota isn't an integer multiple of the total, we can
 326         * use the remainder as spare MSIs for anyone that wants them. */
 327        counts.spare += total % counts.num_devices;
 328
 329        /* Divide any spare by the number of over-quota requestors */
 330        if (counts.over_quota)
 331                counts.quota += counts.spare / counts.over_quota;
 332
 333        /* And finally clamp the request to the possibly adjusted quota */
 334        request = min(counts.quota, request);
 335
 336        pr_debug("rtas_msi: request clamped to quota %d\n", request);
 337out:
 338        of_node_put(pe_dn);
 339
 340        return request;
 341}
 342
 343static int check_msix_entries(struct pci_dev *pdev)
 344{
 345        struct msi_desc *entry;
 346        int expected;
 347
 348        /* There's no way for us to express to firmware that we want
 349         * a discontiguous, or non-zero based, range of MSI-X entries.
 350         * So we must reject such requests. */
 351
 352        expected = 0;
 353        for_each_pci_msi_entry(entry, pdev) {
 354                if (entry->msi_attrib.entry_nr != expected) {
 355                        pr_debug("rtas_msi: bad MSI-X entries.\n");
 356                        return -EINVAL;
 357                }
 358                expected++;
 359        }
 360
 361        return 0;
 362}
 363
 364static void rtas_hack_32bit_msi_gen2(struct pci_dev *pdev)
 365{
 366        u32 addr_hi, addr_lo;
 367
 368        /*
 369         * We should only get in here for IODA1 configs. This is based on the
 370         * fact that we using RTAS for MSIs, we don't have the 32 bit MSI RTAS
 371         * support, and we are in a PCIe Gen2 slot.
 372         */
 373        dev_info(&pdev->dev,
 374                 "rtas_msi: No 32 bit MSI firmware support, forcing 32 bit MSI\n");
 375        pci_read_config_dword(pdev, pdev->msi_cap + PCI_MSI_ADDRESS_HI, &addr_hi);
 376        addr_lo = 0xffff0000 | ((addr_hi >> (48 - 32)) << 4);
 377        pci_write_config_dword(pdev, pdev->msi_cap + PCI_MSI_ADDRESS_LO, addr_lo);
 378        pci_write_config_dword(pdev, pdev->msi_cap + PCI_MSI_ADDRESS_HI, 0);
 379}
 380
 381static int rtas_setup_msi_irqs(struct pci_dev *pdev, int nvec_in, int type)
 382{
 383        struct pci_dn *pdn;
 384        int hwirq, virq, i, quota, rc;
 385        struct msi_desc *entry;
 386        struct msi_msg msg;
 387        int nvec = nvec_in;
 388        int use_32bit_msi_hack = 0;
 389
 390        if (type == PCI_CAP_ID_MSIX)
 391                rc = check_req_msix(pdev, nvec);
 392        else
 393                rc = check_req_msi(pdev, nvec);
 394
 395        if (rc)
 396                return rc;
 397
 398        quota = msi_quota_for_device(pdev, nvec);
 399
 400        if (quota && quota < nvec)
 401                return quota;
 402
 403        if (type == PCI_CAP_ID_MSIX && check_msix_entries(pdev))
 404                return -EINVAL;
 405
 406        /*
 407         * Firmware currently refuse any non power of two allocation
 408         * so we round up if the quota will allow it.
 409         */
 410        if (type == PCI_CAP_ID_MSIX) {
 411                int m = roundup_pow_of_two(nvec);
 412                quota = msi_quota_for_device(pdev, m);
 413
 414                if (quota >= m)
 415                        nvec = m;
 416        }
 417
 418        pdn = pci_get_pdn(pdev);
 419
 420        /*
 421         * Try the new more explicit firmware interface, if that fails fall
 422         * back to the old interface. The old interface is known to never
 423         * return MSI-Xs.
 424         */
 425again:
 426        if (type == PCI_CAP_ID_MSI) {
 427                if (pdev->no_64bit_msi) {
 428                        rc = rtas_change_msi(pdn, RTAS_CHANGE_32MSI_FN, nvec);
 429                        if (rc < 0) {
 430                                /*
 431                                 * We only want to run the 32 bit MSI hack below if
 432                                 * the max bus speed is Gen2 speed
 433                                 */
 434                                if (pdev->bus->max_bus_speed != PCIE_SPEED_5_0GT)
 435                                        return rc;
 436
 437                                use_32bit_msi_hack = 1;
 438                        }
 439                } else
 440                        rc = -1;
 441
 442                if (rc < 0)
 443                        rc = rtas_change_msi(pdn, RTAS_CHANGE_MSI_FN, nvec);
 444
 445                if (rc < 0) {
 446                        pr_debug("rtas_msi: trying the old firmware call.\n");
 447                        rc = rtas_change_msi(pdn, RTAS_CHANGE_FN, nvec);
 448                }
 449
 450                if (use_32bit_msi_hack && rc > 0)
 451                        rtas_hack_32bit_msi_gen2(pdev);
 452        } else
 453                rc = rtas_change_msi(pdn, RTAS_CHANGE_MSIX_FN, nvec);
 454
 455        if (rc != nvec) {
 456                if (nvec != nvec_in) {
 457                        nvec = nvec_in;
 458                        goto again;
 459                }
 460                pr_debug("rtas_msi: rtas_change_msi() failed\n");
 461                return rc;
 462        }
 463
 464        i = 0;
 465        for_each_pci_msi_entry(entry, pdev) {
 466                hwirq = rtas_query_irq_number(pdn, i++);
 467                if (hwirq < 0) {
 468                        pr_debug("rtas_msi: error (%d) getting hwirq\n", rc);
 469                        return hwirq;
 470                }
 471
 472                virq = irq_create_mapping(NULL, hwirq);
 473
 474                if (!virq) {
 475                        pr_debug("rtas_msi: Failed mapping hwirq %d\n", hwirq);
 476                        return -ENOSPC;
 477                }
 478
 479                dev_dbg(&pdev->dev, "rtas_msi: allocated virq %d\n", virq);
 480                irq_set_msi_desc(virq, entry);
 481
 482                /* Read config space back so we can restore after reset */
 483                __pci_read_msi_msg(entry, &msg);
 484                entry->msg = msg;
 485        }
 486
 487        return 0;
 488}
 489
 490static void rtas_msi_pci_irq_fixup(struct pci_dev *pdev)
 491{
 492        /* No LSI -> leave MSIs (if any) configured */
 493        if (!pdev->irq) {
 494                dev_dbg(&pdev->dev, "rtas_msi: no LSI, nothing to do.\n");
 495                return;
 496        }
 497
 498        /* No MSI -> MSIs can't have been assigned by fw, leave LSI */
 499        if (check_req_msi(pdev, 1) && check_req_msix(pdev, 1)) {
 500                dev_dbg(&pdev->dev, "rtas_msi: no req#msi/x, nothing to do.\n");
 501                return;
 502        }
 503
 504        dev_dbg(&pdev->dev, "rtas_msi: disabling existing MSI.\n");
 505        rtas_disable_msi(pdev);
 506}
 507
 508static int rtas_msi_init(void)
 509{
 510        struct pci_controller *phb;
 511
 512        query_token  = rtas_token("ibm,query-interrupt-source-number");
 513        change_token = rtas_token("ibm,change-msi");
 514
 515        if ((query_token == RTAS_UNKNOWN_SERVICE) ||
 516                        (change_token == RTAS_UNKNOWN_SERVICE)) {
 517                pr_debug("rtas_msi: no RTAS tokens, no MSI support.\n");
 518                return -1;
 519        }
 520
 521        pr_debug("rtas_msi: Registering RTAS MSI callbacks.\n");
 522
 523        WARN_ON(pseries_pci_controller_ops.setup_msi_irqs);
 524        pseries_pci_controller_ops.setup_msi_irqs = rtas_setup_msi_irqs;
 525        pseries_pci_controller_ops.teardown_msi_irqs = rtas_teardown_msi_irqs;
 526
 527        list_for_each_entry(phb, &hose_list, list_node) {
 528                WARN_ON(phb->controller_ops.setup_msi_irqs);
 529                phb->controller_ops.setup_msi_irqs = rtas_setup_msi_irqs;
 530                phb->controller_ops.teardown_msi_irqs = rtas_teardown_msi_irqs;
 531        }
 532
 533        WARN_ON(ppc_md.pci_irq_fixup);
 534        ppc_md.pci_irq_fixup = rtas_msi_pci_irq_fixup;
 535
 536        return 0;
 537}
 538machine_arch_initcall(pseries, rtas_msi_init);
 539