arch/powerpc/platforms/powernv/vas.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright 2016-17 IBM Corp.
   4  */
   5
   6 #define pr_fmt(fmt) "vas: " fmt
   7
   8 #include <linux/module.h>
   9 #include <linux/kernel.h>
  10 #include <linux/export.h>
  11 #include <linux/types.h>
  12 #include <linux/slab.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/of_platform.h>
  15 #include <linux/of_address.h>
  16 #include <linux/of.h>
  17 #include <linux/irqdomain.h>
  18 #include <linux/interrupt.h>
  19 #include <asm/prom.h>
  20 #include <asm/xive.h>
  21
  22 #include "vas.h"
  23
  24 DEFINE_MUTEX(vas_mutex);
  25 static LIST_HEAD(vas_instances);
  26
  27 static DEFINE_PER_CPU(int, cpu_vas_id);
  28
  29 static int vas_irq_fault_window_setup(struct vas_instance *vinst)
  30 {
  31         int rc = 0;
  32
  33         rc = request_threaded_irq(vinst->virq, vas_fault_handler,
  34                                 vas_fault_thread_fn, 0, vinst->name, vinst);
  35
  36         if (rc) {
  37                 pr_err("VAS[%d]: Request IRQ(%d) failed with %d\n",
  38                                 vinst->vas_id, vinst->virq, rc);
  39                 goto out;
  40         }
  41
  42         rc = vas_setup_fault_window(vinst);
  43         if (rc)
  44                 free_irq(vinst->virq, vinst);
  45
  46 out:
  47         return rc;
  48 }
  49
  50 static int init_vas_instance(struct platform_device *pdev)
  51 {
  52         struct device_node *dn = pdev->dev.of_node;
  53         struct vas_instance *vinst;
  54         struct xive_irq_data *xd;
  55         uint32_t chipid, hwirq;
  56         struct resource *res;
  57         int rc, cpu, vasid;
  58
  59         rc = of_property_read_u32(dn, "ibm,vas-id", &vasid);
  60         if (rc) {
  61                 pr_err("No ibm,vas-id property for %s?\n", pdev->name);
  62                 return -ENODEV;
  63         }
  64
  65         rc = of_property_read_u32(dn, "ibm,chip-id", &chipid);
  66         if (rc) {
  67                 pr_err("No ibm,chip-id property for %s?\n", pdev->name);
  68                 return -ENODEV;
  69         }
  70
  71         if (pdev->num_resources != 4) {
  72                 pr_err("Unexpected DT configuration for [%s, %d]\n",
  73                                 pdev->name, vasid);
  74                 return -ENODEV;
  75         }
  76
  77         vinst = kzalloc(sizeof(*vinst), GFP_KERNEL);
  78         if (!vinst)
  79                 return -ENOMEM;
  80
  81         vinst->name = kasprintf(GFP_KERNEL, "vas-%d", vasid);
  82         if (!vinst->name) {
  83                 kfree(vinst);
  84                 return -ENOMEM;
  85         }
  86
  87         INIT_LIST_HEAD(&vinst->node);
  88         ida_init(&vinst->ida);
  89         mutex_init(&vinst->mutex);
  90         vinst->vas_id = vasid;
  91         vinst->pdev = pdev;
  92
  93         res = &pdev->resource[0];
  94         vinst->hvwc_bar_start = res->start;
  95
  96         res = &pdev->resource[1];
  97         vinst->uwc_bar_start = res->start;
  98
  99         res = &pdev->resource[2];
 100         vinst->paste_base_addr = res->start;
 101
 102         res = &pdev->resource[3];
 103         if (res->end > 62) {
 104                 pr_err("Bad 'paste_win_id_shift' in DT, %llx\n", res->end);
 105                 goto free_vinst;
 106         }
 107
 108         vinst->paste_win_id_shift = 63 - res->end;
 109
 110         hwirq = xive_native_alloc_irq_on_chip(chipid);
 111         if (!hwirq) {
 112                 pr_err("Inst%d: Unable to allocate global irq for chip %d\n",
 113                                 vinst->vas_id, chipid);
 114                 return -ENOENT;
 115         }
 116
 117         vinst->virq = irq_create_mapping(NULL, hwirq);
 118         if (!vinst->virq) {
 119                 pr_err("Inst%d: Unable to map global irq %d\n",
 120                                 vinst->vas_id, hwirq);
 121                 return -EINVAL;
 122         }
 123
 124         xd = irq_get_handler_data(vinst->virq);
 125         if (!xd) {
 126                 pr_err("Inst%d: Invalid virq %d\n",
 127                                 vinst->vas_id, vinst->virq);
 128                 return -EINVAL;
 129         }
 130
 131         vinst->irq_port = xd->trig_page;
 132         pr_devel("Initialized instance [%s, %d] paste_base 0x%llx paste_win_id_shift 0x%llx IRQ %d Port 0x%llx\n",
 133                         pdev->name, vasid, vinst->paste_base_addr,
 134                         vinst->paste_win_id_shift, vinst->virq,
 135                         vinst->irq_port);
 136
 137         for_each_possible_cpu(cpu) {
 138                 if (cpu_to_chip_id(cpu) == of_get_ibm_chip_id(dn))
 139                         per_cpu(cpu_vas_id, cpu) = vasid;
 140         }
 141
 142         mutex_lock(&vas_mutex);
 143         list_add(&vinst->node, &vas_instances);
 144         mutex_unlock(&vas_mutex);
 145
 146         spin_lock_init(&vinst->fault_lock);
 147         /*
 148          * IRQ and fault handling setup is needed only for user space
 149          * send windows.
 150          */
 151         if (vinst->virq) {
 152                 rc = vas_irq_fault_window_setup(vinst);
 153                 /*
 154                  * Fault window is used only for user space send windows.
 155                  * So if vinst->virq is NULL, tx_win_open returns -ENODEV
 156                  * for user space.
 157                  */
 158                 if (rc)
 159                         vinst->virq = 0;
 160         }
 161
 162         vas_instance_init_dbgdir(vinst);
 163
 164         dev_set_drvdata(&pdev->dev, vinst);
 165
 166         return 0;
 167
 168 free_vinst:
 169         kfree(vinst->name);
 170         kfree(vinst);
 171         return -ENODEV;
 172
 173 }
 174
 175 /*
 176  * Although this is read/used multiple times, it is written to only
 177  * during initialization.
 178  */
 179 struct vas_instance *find_vas_instance(int vasid)
 180 {
 181         struct list_head *ent;
 182         struct vas_instance *vinst;
 183
 184         mutex_lock(&vas_mutex);
 185
 186         if (vasid == -1)
 187                 vasid = per_cpu(cpu_vas_id, smp_processor_id());
 188
 189         list_for_each(ent, &vas_instances) {
 190                 vinst = list_entry(ent, struct vas_instance, node);
 191                 if (vinst->vas_id == vasid) {
 192                         mutex_unlock(&vas_mutex);
 193                         return vinst;
 194                 }
 195         }
 196         mutex_unlock(&vas_mutex);
 197
 198         pr_devel("Instance %d not found\n", vasid);
 199         return NULL;
 200 }
 201
 202 int chip_to_vas_id(int chipid)
 203 {
 204         int cpu;
 205
 206         for_each_possible_cpu(cpu) {
 207                 if (cpu_to_chip_id(cpu) == chipid)
 208                         return per_cpu(cpu_vas_id, cpu);
 209         }
 210         return -1;
 211 }
 212 EXPORT_SYMBOL(chip_to_vas_id);
 213
 214 static int vas_probe(struct platform_device *pdev)
 215 {
 216         return init_vas_instance(pdev);
 217 }
 218
 219 static const struct of_device_id powernv_vas_match[] = {
 220         { .compatible = "ibm,vas",},
 221         {},
 222 };
 223
 224 static struct platform_driver vas_driver = {
 225         .driver = {
 226                 .name = "vas",
 227                 .of_match_table = powernv_vas_match,
 228         },
 229         .probe = vas_probe,
 230 };
 231
 232 static int __init vas_init(void)
 233 {
 234         int found = 0;
 235         struct device_node *dn;
 236
 237         platform_driver_register(&vas_driver);
 238
 239         for_each_compatible_node(dn, NULL, "ibm,vas") {
 240                 of_platform_device_create(dn, NULL, NULL);
 241                 found++;
 242         }
 243
 244         if (!found) {
 245                 platform_driver_unregister(&vas_driver);
 246                 return -ENODEV;
 247         }
 248
 249         pr_devel("Found %d instances\n", found);
 250
 251         return 0;
 252 }
 253 device_initcall(vas_init);