linux/drivers/fmc/fmc-sdb.c
<<
>>
Prefs
   1/*
   2 * Copyright (C) 2012 CERN (www.cern.ch)
   3 * Author: Alessandro Rubini <rubini@gnudd.com>
   4 *
   5 * Released according to the GNU GPL, version 2 or any later version.
   6 *
   7 * This work is part of the White Rabbit project, a research effort led
   8 * by CERN, the European Institute for Nuclear Research.
   9 */
  10#include <linux/module.h>
  11#include <linux/slab.h>
  12#include <linux/fmc.h>
  13#include <linux/sdb.h>
  14#include <linux/err.h>
  15#include <linux/fmc-sdb.h>
  16#include <asm/byteorder.h>
  17
  18static uint32_t __sdb_rd(struct fmc_device *fmc, unsigned long address,
  19                        int convert)
  20{
  21        uint32_t res = fmc_readl(fmc, address);
  22        if (convert)
  23                return __be32_to_cpu(res);
  24        return res;
  25}
  26
  27static struct sdb_array *__fmc_scan_sdb_tree(struct fmc_device *fmc,
  28                                             unsigned long sdb_addr,
  29                                             unsigned long reg_base, int level)
  30{
  31        uint32_t onew;
  32        int i, j, n, convert = 0;
  33        struct sdb_array *arr, *sub;
  34
  35        onew = fmc_readl(fmc, sdb_addr);
  36        if (onew == SDB_MAGIC) {
  37                /* Uh! If we are little-endian, we must convert */
  38                if (SDB_MAGIC != __be32_to_cpu(SDB_MAGIC))
  39                        convert = 1;
  40        } else if (onew == __be32_to_cpu(SDB_MAGIC)) {
  41                /* ok, don't convert */
  42        } else {
  43                return ERR_PTR(-ENOENT);
  44        }
  45        /* So, the magic was there: get the count from offset 4*/
  46        onew = __sdb_rd(fmc, sdb_addr + 4, convert);
  47        n = __be16_to_cpu(*(uint16_t *)&onew);
  48        arr = kzalloc(sizeof(*arr), GFP_KERNEL);
  49        if (!arr)
  50                return ERR_PTR(-ENOMEM);
  51        arr->record = kzalloc(sizeof(arr->record[0]) * n, GFP_KERNEL);
  52        arr->subtree = kzalloc(sizeof(arr->subtree[0]) * n, GFP_KERNEL);
  53        if (!arr->record || !arr->subtree) {
  54                kfree(arr->record);
  55                kfree(arr->subtree);
  56                kfree(arr);
  57                return ERR_PTR(-ENOMEM);
  58        }
  59
  60        arr->len = n;
  61        arr->level = level;
  62        arr->fmc = fmc;
  63        for (i = 0; i < n; i++) {
  64                union  sdb_record *r;
  65
  66                for (j = 0; j < sizeof(arr->record[0]); j += 4) {
  67                        *(uint32_t *)((void *)(arr->record + i) + j) =
  68                                __sdb_rd(fmc, sdb_addr + (i * 64) + j, convert);
  69                }
  70                r = &arr->record[i];
  71                arr->subtree[i] = ERR_PTR(-ENODEV);
  72                if (r->empty.record_type == sdb_type_bridge) {
  73                        struct sdb_component *c = &r->bridge.sdb_component;
  74                        uint64_t subaddr = __be64_to_cpu(r->bridge.sdb_child);
  75                        uint64_t newbase = __be64_to_cpu(c->addr_first);
  76
  77                        subaddr += reg_base;
  78                        newbase += reg_base;
  79                        sub = __fmc_scan_sdb_tree(fmc, subaddr, newbase,
  80                                                  level + 1);
  81                        arr->subtree[i] = sub; /* may be error */
  82                        if (IS_ERR(sub))
  83                                continue;
  84                        sub->parent = arr;
  85                        sub->baseaddr = newbase;
  86                }
  87        }
  88        return arr;
  89}
  90
  91int fmc_scan_sdb_tree(struct fmc_device *fmc, unsigned long address)
  92{
  93        struct sdb_array *ret;
  94        if (fmc->sdb)
  95                return -EBUSY;
  96        ret = __fmc_scan_sdb_tree(fmc, address, 0 /* regs */, 0);
  97        if (IS_ERR(ret))
  98                return PTR_ERR(ret);
  99        fmc->sdb = ret;
 100        return 0;
 101}
 102EXPORT_SYMBOL(fmc_scan_sdb_tree);
 103
 104static void __fmc_sdb_free(struct sdb_array *arr)
 105{
 106        int i, n;
 107
 108        if (!arr)
 109                return;
 110        n = arr->len;
 111        for (i = 0; i < n; i++) {
 112                if (IS_ERR(arr->subtree[i]))
 113                        continue;
 114                __fmc_sdb_free(arr->subtree[i]);
 115        }
 116        kfree(arr->record);
 117        kfree(arr->subtree);
 118        kfree(arr);
 119}
 120
 121int fmc_free_sdb_tree(struct fmc_device *fmc)
 122{
 123        __fmc_sdb_free(fmc->sdb);
 124        fmc->sdb = NULL;
 125        return 0;
 126}
 127EXPORT_SYMBOL(fmc_free_sdb_tree);
 128
 129/* This helper calls reprogram and inizialized sdb as well */
 130int fmc_reprogram(struct fmc_device *fmc, struct fmc_driver *d, char *gw,
 131                         int sdb_entry)
 132{
 133        int ret;
 134
 135        ret = fmc->op->reprogram(fmc, d, gw);
 136        if (ret < 0)
 137                return ret;
 138        if (sdb_entry < 0)
 139                return ret;
 140
 141        /* We are required to find SDB at a given offset */
 142        ret = fmc_scan_sdb_tree(fmc, sdb_entry);
 143        if (ret < 0) {
 144                dev_err(&fmc->dev, "Can't find SDB at address 0x%x\n",
 145                        sdb_entry);
 146                return -ENODEV;
 147        }
 148        fmc_dump_sdb(fmc);
 149        return 0;
 150}
 151EXPORT_SYMBOL(fmc_reprogram);
 152
 153static void __fmc_show_sdb_tree(const struct fmc_device *fmc,
 154                                const struct sdb_array *arr)
 155{
 156        int i, j, n = arr->len, level = arr->level;
 157        const struct sdb_array *ap;
 158
 159        for (i = 0; i < n; i++) {
 160                unsigned long base;
 161                union  sdb_record *r;
 162                struct sdb_product *p;
 163                struct sdb_component *c;
 164                r = &arr->record[i];
 165                c = &r->dev.sdb_component;
 166                p = &c->product;
 167                base = 0;
 168                for (ap = arr; ap; ap = ap->parent)
 169                        base += ap->baseaddr;
 170                dev_info(&fmc->dev, "SDB: ");
 171
 172                for (j = 0; j < level; j++)
 173                        printk(KERN_CONT "   ");
 174                switch (r->empty.record_type) {
 175                case sdb_type_interconnect:
 176                        printk(KERN_CONT "%08llx:%08x %.19s\n",
 177                               __be64_to_cpu(p->vendor_id),
 178                               __be32_to_cpu(p->device_id),
 179                               p->name);
 180                        break;
 181                case sdb_type_device:
 182                        printk(KERN_CONT "%08llx:%08x %.19s (%08llx-%08llx)\n",
 183                               __be64_to_cpu(p->vendor_id),
 184                               __be32_to_cpu(p->device_id),
 185                               p->name,
 186                               __be64_to_cpu(c->addr_first) + base,
 187                               __be64_to_cpu(c->addr_last) + base);
 188                        break;
 189                case sdb_type_bridge:
 190                        printk(KERN_CONT "%08llx:%08x %.19s (bridge: %08llx)\n",
 191                               __be64_to_cpu(p->vendor_id),
 192                               __be32_to_cpu(p->device_id),
 193                               p->name,
 194                               __be64_to_cpu(c->addr_first) + base);
 195                        if (IS_ERR(arr->subtree[i])) {
 196                                printk(KERN_CONT "(bridge error %li)\n",
 197                                       PTR_ERR(arr->subtree[i]));
 198                                break;
 199                        }
 200                        __fmc_show_sdb_tree(fmc, arr->subtree[i]);
 201                        break;
 202                case sdb_type_integration:
 203                        printk(KERN_CONT "integration\n");
 204                        break;
 205                case sdb_type_repo_url:
 206                        printk(KERN_CONT "repo-url\n");
 207                        break;
 208                case sdb_type_synthesis:
 209                        printk(KERN_CONT "synthesis-info\n");
 210                        break;
 211                case sdb_type_empty:
 212                        printk(KERN_CONT "empty\n");
 213                        break;
 214                default:
 215                        printk(KERN_CONT "UNKNOWN TYPE 0x%02x\n",
 216                               r->empty.record_type);
 217                        break;
 218                }
 219        }
 220}
 221
 222void fmc_show_sdb_tree(const struct fmc_device *fmc)
 223{
 224        if (!fmc->sdb)
 225                return;
 226        __fmc_show_sdb_tree(fmc, fmc->sdb);
 227}
 228EXPORT_SYMBOL(fmc_show_sdb_tree);
 229
 230signed long fmc_find_sdb_device(struct sdb_array *tree,
 231                                uint64_t vid, uint32_t did, unsigned long *sz)
 232{
 233        signed long res = -ENODEV;
 234        union  sdb_record *r;
 235        struct sdb_product *p;
 236        struct sdb_component *c;
 237        int i, n = tree->len;
 238        uint64_t last, first;
 239
 240        /* FIXME: what if the first interconnect is not at zero? */
 241        for (i = 0; i < n; i++) {
 242                r = &tree->record[i];
 243                c = &r->dev.sdb_component;
 244                p = &c->product;
 245
 246                if (!IS_ERR(tree->subtree[i]))
 247                        res = fmc_find_sdb_device(tree->subtree[i],
 248                                                  vid, did, sz);
 249                if (res >= 0)
 250                        return res + tree->baseaddr;
 251                if (r->empty.record_type != sdb_type_device)
 252                        continue;
 253                if (__be64_to_cpu(p->vendor_id) != vid)
 254                        continue;
 255                if (__be32_to_cpu(p->device_id) != did)
 256                        continue;
 257                /* found */
 258                last = __be64_to_cpu(c->addr_last);
 259                first = __be64_to_cpu(c->addr_first);
 260                if (sz)
 261                        *sz = (typeof(*sz))(last + 1 - first);
 262                return first + tree->baseaddr;
 263        }
 264        return res;
 265}
 266EXPORT_SYMBOL(fmc_find_sdb_device);
 267
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.