1 /* 2 * Copyright 2016-17 IBM Corp. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public License 6 * as published by the Free Software Foundation; either version 7 * 2 of the License, or (at your option) any later version. 8 */ 9 10 #define pr_fmt(fmt) "vas: " fmt 11 12 #include <linux/module.h> 13 #include <linux/kernel.h> 14 #include <linux/export.h> 15 #include <linux/types.h> 16 #include <linux/slab.h> 17 #include <linux/platform_device.h> 18 #include <linux/of_platform.h> 19 #include <linux/of_address.h> 20 #include <linux/of.h> 21 #include <asm/prom.h> 22 23 #include "vas.h" 24 25 static DEFINE_MUTEX(vas_mutex); 26 static LIST_HEAD(vas_instances); 27 28 static DEFINE_PER_CPU(int, cpu_vas_id); 29 30 static int init_vas_instance(struct platform_device *pdev) 31 { 32 int rc, cpu, vasid; 33 struct resource *res; 34 struct vas_instance *vinst; 35 struct device_node *dn = pdev->dev.of_node; 36 37 rc = of_property_read_u32(dn, "ibm,vas-id", &vasid); 38 if (rc) { 39 pr_err("No ibm,vas-id property for %s?\n", pdev->name); 40 return -ENODEV; 41 } 42 43 if (pdev->num_resources != 4) { 44 pr_err("Unexpected DT configuration for [%s, %d]\n", 45 pdev->name, vasid); 46 return -ENODEV; 47 } 48 49 vinst = kzalloc(sizeof(*vinst), GFP_KERNEL); 50 if (!vinst) 51 return -ENOMEM; 52 53 INIT_LIST_HEAD(&vinst->node); 54 ida_init(&vinst->ida); 55 mutex_init(&vinst->mutex); 56 vinst->vas_id = vasid; 57 vinst->pdev = pdev; 58 59 res = &pdev->resource[0]; 60 vinst->hvwc_bar_start = res->start; 61 62 res = &pdev->resource[1]; 63 vinst->uwc_bar_start = res->start; 64 65 res = &pdev->resource[2]; 66 vinst->paste_base_addr = res->start; 67 68 res = &pdev->resource[3]; 69 if (res->end > 62) { 70 pr_err("Bad 'paste_win_id_shift' in DT, %llx\n", res->end); 71 goto free_vinst; 72 } 73 74 vinst->paste_win_id_shift = 63 - res->end; 75 76 pr_devel("Initialized instance [%s, %d], paste_base 0x%llx, " 77 "paste_win_id_shift 0x%llx\n", pdev->name, vasid, 78 vinst->paste_base_addr, vinst->paste_win_id_shift); 79 80 for_each_possible_cpu(cpu) { 81 if (cpu_to_chip_id(cpu) == of_get_ibm_chip_id(dn)) 82 per_cpu(cpu_vas_id, cpu) = vasid; 83 } 84 85 mutex_lock(&vas_mutex); 86 list_add(&vinst->node, &vas_instances); 87 mutex_unlock(&vas_mutex); 88 89 dev_set_drvdata(&pdev->dev, vinst); 90 91 return 0; 92 93 free_vinst: 94 kfree(vinst); 95 return -ENODEV; 96 97 } 98 99 /* 100 * Although this is read/used multiple times, it is written to only 101 * during initialization. 102 */ 103 struct vas_instance *find_vas_instance(int vasid) 104 { 105 struct list_head *ent; 106 struct vas_instance *vinst; 107 108 mutex_lock(&vas_mutex); 109 110 if (vasid == -1) 111 vasid = per_cpu(cpu_vas_id, smp_processor_id()); 112 113 list_for_each(ent, &vas_instances) { 114 vinst = list_entry(ent, struct vas_instance, node); 115 if (vinst->vas_id == vasid) { 116 mutex_unlock(&vas_mutex); 117 return vinst; 118 } 119 } 120 mutex_unlock(&vas_mutex); 121 122 pr_devel("Instance %d not found\n", vasid); 123 return NULL; 124 } 125 126 static int vas_probe(struct platform_device *pdev) 127 { 128 return init_vas_instance(pdev); 129 } 130 131 static const struct of_device_id powernv_vas_match[] = { 132 { .compatible = "ibm,vas",}, 133 {}, 134 }; 135 136 static struct platform_driver vas_driver = { 137 .driver = { 138 .name = "vas", 139 .of_match_table = powernv_vas_match, 140 }, 141 .probe = vas_probe, 142 }; 143 144 static int __init vas_init(void) 145 { 146 int found = 0; 147 struct device_node *dn; 148 149 platform_driver_register(&vas_driver); 150 151 for_each_compatible_node(dn, NULL, "ibm,vas") { 152 of_platform_device_create(dn, NULL, NULL); 153 found++; 154 } 155 156 if (!found) 157 return -ENODEV; 158 159 pr_devel("Found %d instances\n", found); 160 161 return 0; 162 } 163 device_initcall(vas_init); 164