vexpress-syscfg.c revision fc96e661a57d5e4de01503d460116cce7ced7e70
1/* 2 * This program is free software; you can redistribute it and/or modify 3 * it under the terms of the GNU General Public License version 2 as 4 * published by the Free Software Foundation. 5 * 6 * This program is distributed in the hope that it will be useful, 7 * but WITHOUT ANY WARRANTY; without even the implied warranty of 8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 9 * GNU General Public License for more details. 10 * 11 * Copyright (C) 2014 ARM Limited 12 */ 13 14#include <linux/delay.h> 15#include <linux/err.h> 16#include <linux/io.h> 17#include <linux/of.h> 18#include <linux/platform_device.h> 19#include <linux/sched.h> 20#include <linux/slab.h> 21#include <linux/syscore_ops.h> 22#include <linux/vexpress.h> 23 24 25#define SYS_CFGDATA 0x0 26 27#define SYS_CFGCTRL 0x4 28#define SYS_CFGCTRL_START (1 << 31) 29#define SYS_CFGCTRL_WRITE (1 << 30) 30#define SYS_CFGCTRL_DCC(n) (((n) & 0xf) << 26) 31#define SYS_CFGCTRL_FUNC(n) (((n) & 0x3f) << 20) 32#define SYS_CFGCTRL_SITE(n) (((n) & 0x3) << 16) 33#define SYS_CFGCTRL_POSITION(n) (((n) & 0xf) << 12) 34#define SYS_CFGCTRL_DEVICE(n) (((n) & 0xfff) << 0) 35 36#define SYS_CFGSTAT 0x8 37#define SYS_CFGSTAT_ERR (1 << 1) 38#define SYS_CFGSTAT_COMPLETE (1 << 0) 39 40 41struct vexpress_syscfg { 42 struct device *dev; 43 void __iomem *base; 44 struct list_head funcs; 45}; 46 47struct vexpress_syscfg_func { 48 struct list_head list; 49 struct vexpress_syscfg *syscfg; 50 struct regmap *regmap; 51 int num_templates; 52 u32 template[0]; /* Keep it last! */ 53}; 54 55 56static int vexpress_syscfg_exec(struct vexpress_syscfg_func *func, 57 int index, bool write, u32 *data) 58{ 59 struct vexpress_syscfg *syscfg = func->syscfg; 60 u32 command, status; 61 int tries; 62 long timeout; 63 64 if (WARN_ON(index > func->num_templates)) 65 return -EINVAL; 66 67 command = readl(syscfg->base + SYS_CFGCTRL); 68 if (WARN_ON(command & SYS_CFGCTRL_START)) 69 return -EBUSY; 70 71 command = func->template[index]; 72 command |= SYS_CFGCTRL_START; 73 command |= write ? SYS_CFGCTRL_WRITE : 0; 74 75 /* Use a canary for reads */ 76 if (!write) 77 *data = 0xdeadbeef; 78 79 dev_dbg(syscfg->dev, "func %p, command %x, data %x\n", 80 func, command, *data); 81 writel(*data, syscfg->base + SYS_CFGDATA); 82 writel(0, syscfg->base + SYS_CFGSTAT); 83 writel(command, syscfg->base + SYS_CFGCTRL); 84 mb(); 85 86 /* The operation can take ages... Go to sleep, 100us initially */ 87 tries = 100; 88 timeout = 100; 89 do { 90 if (!irqs_disabled()) { 91 set_current_state(TASK_INTERRUPTIBLE); 92 schedule_timeout(usecs_to_jiffies(timeout)); 93 if (signal_pending(current)) 94 return -EINTR; 95 } else { 96 udelay(timeout); 97 } 98 99 status = readl(syscfg->base + SYS_CFGSTAT); 100 if (status & SYS_CFGSTAT_ERR) 101 return -EFAULT; 102 103 if (timeout > 20) 104 timeout -= 20; 105 } while (--tries && !(status & SYS_CFGSTAT_COMPLETE)); 106 if (WARN_ON_ONCE(!tries)) 107 return -ETIMEDOUT; 108 109 if (!write) { 110 *data = readl(syscfg->base + SYS_CFGDATA); 111 dev_dbg(syscfg->dev, "func %p, read data %x\n", func, *data); 112 } 113 114 return 0; 115} 116 117static int vexpress_syscfg_read(void *context, unsigned int index, 118 unsigned int *val) 119{ 120 struct vexpress_syscfg_func *func = context; 121 122 return vexpress_syscfg_exec(func, index, false, val); 123} 124 125static int vexpress_syscfg_write(void *context, unsigned int index, 126 unsigned int val) 127{ 128 struct vexpress_syscfg_func *func = context; 129 130 return vexpress_syscfg_exec(func, index, true, &val); 131} 132 133struct regmap_config vexpress_syscfg_regmap_config = { 134 .lock = vexpress_config_lock, 135 .unlock = vexpress_config_unlock, 136 .reg_bits = 32, 137 .val_bits = 32, 138 .reg_read = vexpress_syscfg_read, 139 .reg_write = vexpress_syscfg_write, 140 .reg_format_endian = REGMAP_ENDIAN_LITTLE, 141 .val_format_endian = REGMAP_ENDIAN_LITTLE, 142}; 143 144 145static struct regmap *vexpress_syscfg_regmap_init(struct device *dev, 146 void *context) 147{ 148 struct platform_device *pdev = to_platform_device(dev); 149 struct vexpress_syscfg *syscfg = context; 150 struct vexpress_syscfg_func *func; 151 struct property *prop; 152 const __be32 *val = NULL; 153 __be32 energy_quirk[4]; 154 int num; 155 u32 site, position, dcc; 156 int i; 157 158 if (dev->of_node) { 159 int err = vexpress_config_get_topo(dev->of_node, &site, 160 &position, &dcc); 161 162 if (err) 163 return ERR_PTR(err); 164 165 prop = of_find_property(dev->of_node, 166 "arm,vexpress-sysreg,func", NULL); 167 if (!prop) 168 return ERR_PTR(-EINVAL); 169 170 num = prop->length / sizeof(u32) / 2; 171 val = prop->value; 172 } else { 173 if (pdev->num_resources != 1 || 174 pdev->resource[0].flags != IORESOURCE_BUS) 175 return ERR_PTR(-EFAULT); 176 177 site = pdev->resource[0].start; 178 if (site == VEXPRESS_SITE_MASTER) 179 site = vexpress_config_get_master(); 180 position = 0; 181 dcc = 0; 182 num = 1; 183 } 184 185 /* 186 * "arm,vexpress-energy" function used to be described 187 * by its first device only, now it requires both 188 */ 189 if (num == 1 && of_device_is_compatible(dev->of_node, 190 "arm,vexpress-energy")) { 191 num = 2; 192 energy_quirk[0] = *val; 193 energy_quirk[2] = *val++; 194 energy_quirk[1] = *val; 195 energy_quirk[3] = cpu_to_be32(be32_to_cpup(val) + 1); 196 val = energy_quirk; 197 } 198 199 func = kzalloc(sizeof(*func) + sizeof(*func->template) * num, 200 GFP_KERNEL); 201 if (!func) 202 return ERR_PTR(-ENOMEM); 203 204 func->syscfg = syscfg; 205 func->num_templates = num; 206 207 for (i = 0; i < num; i++) { 208 u32 function, device; 209 210 if (dev->of_node) { 211 function = be32_to_cpup(val++); 212 device = be32_to_cpup(val++); 213 } else { 214 function = pdev->resource[0].end; 215 device = pdev->id; 216 } 217 218 dev_dbg(dev, "func %p: %u/%u/%u/%u/%u\n", 219 func, site, position, dcc, 220 function, device); 221 222 func->template[i] = SYS_CFGCTRL_DCC(dcc); 223 func->template[i] |= SYS_CFGCTRL_SITE(site); 224 func->template[i] |= SYS_CFGCTRL_POSITION(position); 225 func->template[i] |= SYS_CFGCTRL_FUNC(function); 226 func->template[i] |= SYS_CFGCTRL_DEVICE(device); 227 } 228 229 vexpress_syscfg_regmap_config.max_register = num - 1; 230 231 func->regmap = regmap_init(dev, NULL, func, 232 &vexpress_syscfg_regmap_config); 233 234 if (IS_ERR(func->regmap)) { 235 void *err = func->regmap; 236 237 kfree(func); 238 return err; 239 } 240 241 list_add(&func->list, &syscfg->funcs); 242 243 return func->regmap; 244} 245 246static void vexpress_syscfg_regmap_exit(struct regmap *regmap, void *context) 247{ 248 struct vexpress_syscfg *syscfg = context; 249 struct vexpress_syscfg_func *func, *tmp; 250 251 regmap_exit(regmap); 252 253 list_for_each_entry_safe(func, tmp, &syscfg->funcs, list) { 254 if (func->regmap == regmap) { 255 list_del(&syscfg->funcs); 256 kfree(func); 257 break; 258 } 259 } 260} 261 262static struct vexpress_config_bridge_ops vexpress_syscfg_bridge_ops = { 263 .regmap_init = vexpress_syscfg_regmap_init, 264 .regmap_exit = vexpress_syscfg_regmap_exit, 265}; 266 267 268/* Non-DT hack, to be gone... */ 269static struct device *vexpress_syscfg_bridge; 270 271int vexpress_syscfg_device_register(struct platform_device *pdev) 272{ 273 pdev->dev.parent = vexpress_syscfg_bridge; 274 275 return platform_device_register(pdev); 276} 277 278 279int vexpress_syscfg_probe(struct platform_device *pdev) 280{ 281 struct vexpress_syscfg *syscfg; 282 struct resource *res; 283 struct device *bridge; 284 285 syscfg = devm_kzalloc(&pdev->dev, sizeof(*syscfg), GFP_KERNEL); 286 if (!syscfg) 287 return -ENOMEM; 288 syscfg->dev = &pdev->dev; 289 INIT_LIST_HEAD(&syscfg->funcs); 290 291 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 292 if (!devm_request_mem_region(&pdev->dev, res->start, 293 resource_size(res), pdev->name)) 294 return -EBUSY; 295 296 syscfg->base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); 297 if (!syscfg->base) 298 return -EFAULT; 299 300 /* Must use dev.parent (MFD), as that's where DT phandle points at... */ 301 bridge = vexpress_config_bridge_register(pdev->dev.parent, 302 &vexpress_syscfg_bridge_ops, syscfg); 303 if (IS_ERR(bridge)) 304 return PTR_ERR(bridge); 305 306 /* Non-DT case */ 307 if (!pdev->dev.of_node) 308 vexpress_syscfg_bridge = bridge; 309 310 return 0; 311} 312 313static const struct platform_device_id vexpress_syscfg_id_table[] = { 314 { "vexpress-syscfg", }, 315 {}, 316}; 317 318static struct platform_driver vexpress_syscfg_driver = { 319 .driver.name = "vexpress-syscfg", 320 .id_table = vexpress_syscfg_id_table, 321 .probe = vexpress_syscfg_probe, 322}; 323 324static int __init vexpress_syscfg_init(void) 325{ 326 return platform_driver_register(&vexpress_syscfg_driver); 327} 328core_initcall(vexpress_syscfg_init); 329