drivers/misc/vexpress-syscfg.c

   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/signal.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
  41 struct vexpress_syscfg {
  42         struct device *dev;
  43         void __iomem *base;
  44         struct list_head funcs;
  45 };
  46
  47 struct 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
  56 static 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
 117 static 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
 125 static 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
 133 static struct 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
 145 static struct regmap *vexpress_syscfg_regmap_init(struct device *dev,
 146                 void *context)
 147 {
 148         int err;
 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         err = vexpress_config_get_topo(dev->of_node, &site,
 159                                 &position, &dcc);
 160         if (err)
 161                 return ERR_PTR(err);
 162
 163         prop = of_find_property(dev->of_node,
 164                         "arm,vexpress-sysreg,func", NULL);
 165         if (!prop)
 166                 return ERR_PTR(-EINVAL);
 167
 168         num = prop->length / sizeof(u32) / 2;
 169         val = prop->value;
 170
 171         /*
 172          * "arm,vexpress-energy" function used to be described
 173          * by its first device only, now it requires both
 174          */
 175         if (num == 1 && of_device_is_compatible(dev->of_node,
 176                         "arm,vexpress-energy")) {
 177                 num = 2;
 178                 energy_quirk[0] = *val;
 179                 energy_quirk[2] = *val++;
 180                 energy_quirk[1] = *val;
 181                 energy_quirk[3] = cpu_to_be32(be32_to_cpup(val) + 1);
 182                 val = energy_quirk;
 183         }
 184
 185         func = kzalloc(struct_size(func, template, num), GFP_KERNEL);
 186         if (!func)
 187                 return ERR_PTR(-ENOMEM);
 188
 189         func->syscfg = syscfg;
 190         func->num_templates = num;
 191
 192         for (i = 0; i < num; i++) {
 193                 u32 function, device;
 194
 195                 function = be32_to_cpup(val++);
 196                 device = be32_to_cpup(val++);
 197
 198                 dev_dbg(dev, "func %p: %u/%u/%u/%u/%u\n",
 199                                 func, site, position, dcc,
 200                                 function, device);
 201
 202                 func->template[i] = SYS_CFGCTRL_DCC(dcc);
 203                 func->template[i] |= SYS_CFGCTRL_SITE(site);
 204                 func->template[i] |= SYS_CFGCTRL_POSITION(position);
 205                 func->template[i] |= SYS_CFGCTRL_FUNC(function);
 206                 func->template[i] |= SYS_CFGCTRL_DEVICE(device);
 207         }
 208
 209         vexpress_syscfg_regmap_config.max_register = num - 1;
 210
 211         func->regmap = regmap_init(dev, NULL, func,
 212                         &vexpress_syscfg_regmap_config);
 213
 214         if (IS_ERR(func->regmap)) {
 215                 void *err = func->regmap;
 216
 217                 kfree(func);
 218                 return err;
 219         }
 220
 221         list_add(&func->list, &syscfg->funcs);
 222
 223         return func->regmap;
 224 }
 225
 226 static void vexpress_syscfg_regmap_exit(struct regmap *regmap, void *context)
 227 {
 228         struct vexpress_syscfg *syscfg = context;
 229         struct vexpress_syscfg_func *func, *tmp;
 230
 231         regmap_exit(regmap);
 232
 233         list_for_each_entry_safe(func, tmp, &syscfg->funcs, list) {
 234                 if (func->regmap == regmap) {
 235                         list_del(&syscfg->funcs);
 236                         kfree(func);
 237                         break;
 238                 }
 239         }
 240 }
 241
 242 static struct vexpress_config_bridge_ops vexpress_syscfg_bridge_ops = {
 243         .regmap_init = vexpress_syscfg_regmap_init,
 244         .regmap_exit = vexpress_syscfg_regmap_exit,
 245 };
 246
 247
 248 static int vexpress_syscfg_probe(struct platform_device *pdev)
 249 {
 250         struct vexpress_syscfg *syscfg;
 251         struct resource *res;
 252         struct device *bridge;
 253
 254         syscfg = devm_kzalloc(&pdev->dev, sizeof(*syscfg), GFP_KERNEL);
 255         if (!syscfg)
 256                 return -ENOMEM;
 257         syscfg->dev = &pdev->dev;
 258         INIT_LIST_HEAD(&syscfg->funcs);
 259
 260         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 261         syscfg->base = devm_ioremap_resource(&pdev->dev, res);
 262         if (IS_ERR(syscfg->base))
 263                 return PTR_ERR(syscfg->base);
 264
 265         /* Must use dev.parent (MFD), as that's where DT phandle points at... */
 266         bridge = vexpress_config_bridge_register(pdev->dev.parent,
 267                         &vexpress_syscfg_bridge_ops, syscfg);
 268
 269         return PTR_ERR_OR_ZERO(bridge);
 270 }
 271
 272 static const struct platform_device_id vexpress_syscfg_id_table[] = {
 273         { "vexpress-syscfg", },
 274         {},
 275 };
 276
 277 static struct platform_driver vexpress_syscfg_driver = {
 278         .driver.name = "vexpress-syscfg",
 279         .id_table = vexpress_syscfg_id_table,
 280         .probe = vexpress_syscfg_probe,
 281 };
 282
 283 static int __init vexpress_syscfg_init(void)
 284 {
 285         return platform_driver_register(&vexpress_syscfg_driver);
 286 }
 287 core_initcall(vexpress_syscfg_init);