1 /* 2 * OPAL IMC interface detection driver 3 * Supported on POWERNV platform 4 * 5 * Copyright (C) 2017 Madhavan Srinivasan, IBM Corporation. 6 * (C) 2017 Anju T Sudhakar, IBM Corporation. 7 * (C) 2017 Hemant K Shaw, IBM Corporation. 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License 11 * as published by the Free Software Foundation; either version 12 * 2 of the License, or later version. 13 */ 14 #include <linux/kernel.h> 15 #include <linux/platform_device.h> 16 #include <linux/of.h> 17 #include <linux/of_address.h> 18 #include <linux/of_platform.h> 19 #include <linux/crash_dump.h> 20 #include <asm/opal.h> 21 #include <asm/io.h> 22 #include <asm/imc-pmu.h> 23 #include <asm/cputhreads.h> 24 25 /* 26 * imc_get_mem_addr_nest: Function to get nest counter memory region 27 * for each chip 28 */ 29 static int imc_get_mem_addr_nest(struct device_node *node, 30 struct imc_pmu *pmu_ptr, 31 u32 offset) 32 { 33 int nr_chips = 0, i; 34 u64 *base_addr_arr, baddr; 35 u32 *chipid_arr; 36 37 nr_chips = of_property_count_u32_elems(node, "chip-id"); 38 if (nr_chips <= 0) 39 return -ENODEV; 40 41 base_addr_arr = kcalloc(nr_chips, sizeof(u64), GFP_KERNEL); 42 if (!base_addr_arr) 43 return -ENOMEM; 44 45 chipid_arr = kcalloc(nr_chips, sizeof(u32), GFP_KERNEL); 46 if (!chipid_arr) 47 return -ENOMEM; 48 49 if (of_property_read_u32_array(node, "chip-id", chipid_arr, nr_chips)) 50 goto error; 51 52 if (of_property_read_u64_array(node, "base-addr", base_addr_arr, 53 nr_chips)) 54 goto error; 55 56 pmu_ptr->mem_info = kcalloc(nr_chips, sizeof(struct imc_mem_info), 57 GFP_KERNEL); 58 if (!pmu_ptr->mem_info) 59 goto error; 60 61 for (i = 0; i < nr_chips; i++) { 62 pmu_ptr->mem_info[i].id = chipid_arr[i]; 63 baddr = base_addr_arr[i] + offset; 64 pmu_ptr->mem_info[i].vbase = phys_to_virt(baddr); 65 } 66 67 pmu_ptr->imc_counter_mmaped = true; 68 kfree(base_addr_arr); 69 kfree(chipid_arr); 70 return 0; 71 72 error: 73 kfree(pmu_ptr->mem_info); 74 kfree(base_addr_arr); 75 kfree(chipid_arr); 76 return -1; 77 } 78 79 /* 80 * imc_pmu_create : Takes the parent device which is the pmu unit, pmu_index 81 * and domain as the inputs. 82 * Allocates memory for the struct imc_pmu, sets up its domain, size and offsets 83 */ 84 static int imc_pmu_create(struct device_node *parent, int pmu_index, int domain) 85 { 86 int ret = 0; 87 struct imc_pmu *pmu_ptr; 88 u32 offset; 89 90 /* memory for pmu */ 91 pmu_ptr = kzalloc(sizeof(struct imc_pmu), GFP_KERNEL); 92 if (!pmu_ptr) 93 return -ENOMEM; 94 95 /* Set the domain */ 96 pmu_ptr->domain = domain; 97 98 ret = of_property_read_u32(parent, "size", &pmu_ptr->counter_mem_size); 99 if (ret) { 100 ret = -EINVAL; 101 goto free_pmu; 102 } 103 104 if (!of_property_read_u32(parent, "offset", &offset)) { 105 if (imc_get_mem_addr_nest(parent, pmu_ptr, offset)) { 106 ret = -EINVAL; 107 goto free_pmu; 108 } 109 } 110 111 return 0; 112 113 free_pmu: 114 kfree(pmu_ptr); 115 return ret; 116 } 117 118 static void disable_nest_pmu_counters(void) 119 { 120 int nid, cpu; 121 struct cpumask *l_cpumask; 122 123 get_online_cpus(); 124 for_each_online_node(nid) { 125 l_cpumask = cpumask_of_node(nid); 126 cpu = cpumask_first(l_cpumask); 127 opal_imc_counters_stop(OPAL_IMC_COUNTERS_NEST, 128 get_hard_smp_processor_id(cpu)); 129 } 130 put_online_cpus(); 131 } 132 133 static void disable_core_pmu_counters(void) 134 { 135 cpumask_t cores_map; 136 int cpu, rc; 137 138 get_online_cpus(); 139 /* Disable the IMC Core functions */ 140 cores_map = cpu_online_cores_map(); 141 for_each_cpu(cpu, &cores_map) { 142 rc = opal_imc_counters_stop(OPAL_IMC_COUNTERS_CORE, 143 get_hard_smp_processor_id(cpu)); 144 if (rc) 145 pr_err("%s: Failed to stop Core (cpu = %d)\n", 146 __FUNCTION__, cpu); 147 } 148 put_online_cpus(); 149 } 150 151 static int opal_imc_counters_probe(struct platform_device *pdev) 152 { 153 struct device_node *imc_dev = pdev->dev.of_node; 154 int pmu_count = 0, domain; 155 u32 type; 156 157 /* 158 * Check whether this is kdump kernel. If yes, force the engines to 159 * stop and return. 160 */ 161 if (is_kdump_kernel()) { 162 disable_nest_pmu_counters(); 163 disable_core_pmu_counters(); 164 return -ENODEV; 165 } 166 167 for_each_compatible_node(imc_dev, NULL, IMC_DTB_UNIT_COMPAT) { 168 if (of_property_read_u32(imc_dev, "type", &type)) { 169 pr_warn("IMC Device without type property\n"); 170 continue; 171 } 172 173 switch (type) { 174 case IMC_TYPE_CHIP: 175 domain = IMC_DOMAIN_NEST; 176 break; 177 case IMC_TYPE_CORE: 178 domain =IMC_DOMAIN_CORE; 179 break; 180 case IMC_TYPE_THREAD: 181 domain = IMC_DOMAIN_THREAD; 182 break; 183 default: 184 pr_warn("IMC Unknown Device type \n"); 185 domain = -1; 186 break; 187 } 188 189 if (!imc_pmu_create(imc_dev, pmu_count, domain)) 190 pmu_count++; 191 } 192 193 return 0; 194 } 195 196 static void opal_imc_counters_shutdown(struct platform_device *pdev) 197 { 198 /* 199 * Function only stops the engines which is bare minimum. 200 * TODO: Need to handle proper memory cleanup and pmu 201 * unregister. 202 */ 203 disable_nest_pmu_counters(); 204 disable_core_pmu_counters(); 205 } 206 207 static const struct of_device_id opal_imc_match[] = { 208 { .compatible = IMC_DTB_COMPAT }, 209 {}, 210 }; 211 212 static struct platform_driver opal_imc_driver = { 213 .driver = { 214 .name = "opal-imc-counters", 215 .of_match_table = opal_imc_match, 216 }, 217 .probe = opal_imc_counters_probe, 218 .shutdown = opal_imc_counters_shutdown, 219 }; 220 221 builtin_platform_driver(opal_imc_driver); 222