drivers/mcb/mcb-parse.c

   1 #include <linux/types.h>
   2 #include <linux/ioport.h>
   3 #include <linux/slab.h>
   4 #include <linux/export.h>
   5 #include <linux/io.h>
   6 #include <linux/mcb.h>
   7
   8 #include "mcb-internal.h"
   9
  10 struct mcb_parse_priv {
  11         phys_addr_t mapbase;
  12         void __iomem *base;
  13 };
  14
  15 #define for_each_chameleon_cell(dtype, p)       \
  16         for ((dtype) = get_next_dtype((p));     \
  17              (dtype) != CHAMELEON_DTYPE_END;    \
  18              (dtype) = get_next_dtype((p)))
  19
  20 static inline uint32_t get_next_dtype(void __iomem *p)
  21 {
  22         uint32_t dtype;
  23
  24         dtype = readl(p);
  25         return dtype >> 28;
  26 }
  27
  28 static int chameleon_parse_bdd(struct mcb_bus *bus,
  29                         struct chameleon_bar *cb,
  30                         void __iomem *base)
  31 {
  32         return 0;
  33 }
  34
  35 static int chameleon_parse_gdd(struct mcb_bus *bus,
  36                         struct chameleon_bar *cb,
  37                         void __iomem *base, int bar_count)
  38 {
  39         struct chameleon_gdd __iomem *gdd =
  40                 (struct chameleon_gdd __iomem *) base;
  41         struct mcb_device *mdev;
  42         u32 dev_mapbase;
  43         u32 offset;
  44         u32 size;
  45         int ret;
  46         __le32 reg1;
  47         __le32 reg2;
  48
  49         mdev = mcb_alloc_dev(bus);
  50         if (!mdev)
  51                 return -ENOMEM;
  52
  53         reg1 = readl(&gdd->reg1);
  54         reg2 = readl(&gdd->reg2);
  55         offset = readl(&gdd->offset);
  56         size = readl(&gdd->size);
  57
  58         mdev->id = GDD_DEV(reg1);
  59         mdev->rev = GDD_REV(reg1);
  60         mdev->var = GDD_VAR(reg1);
  61         mdev->bar = GDD_BAR(reg2);
  62         mdev->group = GDD_GRP(reg2);
  63         mdev->inst = GDD_INS(reg2);
  64
  65         /*
  66          * If the BAR is missing, dev_mapbase is zero, or if the
  67          * device is IO mapped we just print a warning and go on with the
  68          * next device, instead of completely stop the gdd parser
  69          */
  70         if (mdev->bar > bar_count - 1) {
  71                 pr_info("No BAR for 16z%03d\n", mdev->id);
  72                 ret = 0;
  73                 goto err;
  74         }
  75
  76         dev_mapbase = cb[mdev->bar].addr;
  77         if (!dev_mapbase) {
  78                 pr_info("BAR not assigned for 16z%03d\n", mdev->id);
  79                 ret = 0;
  80                 goto err;
  81         }
  82
  83         if (dev_mapbase & 0x01) {
  84                 pr_info("IO mapped Device (16z%03d) not yet supported\n",
  85                         mdev->id);
  86                 ret = 0;
  87                 goto err;
  88         }
  89
  90         pr_debug("Found a 16z%03d\n", mdev->id);
  91
  92         mdev->irq.start = GDD_IRQ(reg1);
  93         mdev->irq.end = GDD_IRQ(reg1);
  94         mdev->irq.flags = IORESOURCE_IRQ;
  95
  96         mdev->mem.start = dev_mapbase + offset;
  97
  98         mdev->mem.end = mdev->mem.start + size - 1;
  99         mdev->mem.flags = IORESOURCE_MEM;
 100
 101         ret = mcb_device_register(bus, mdev);
 102         if (ret < 0)
 103                 goto err;
 104
 105         return 0;
 106
 107 err:
 108         mcb_free_dev(mdev);
 109
 110         return ret;
 111 }
 112
 113 static void chameleon_parse_bar(void __iomem *base,
 114                                 struct chameleon_bar *cb, int bar_count)
 115 {
 116         char __iomem *p = base;
 117         int i;
 118
 119         /* skip reg1 */
 120         p += sizeof(__le32);
 121
 122         for (i = 0; i < bar_count; i++) {
 123                 cb[i].addr = readl(p);
 124                 cb[i].size = readl(p + 4);
 125
 126                 p += sizeof(struct chameleon_bar);
 127         }
 128 }
 129
 130 static int chameleon_get_bar(void __iomem **base, phys_addr_t mapbase,
 131                              struct chameleon_bar **cb)
 132 {
 133         struct chameleon_bar *c;
 134         int bar_count;
 135         __le32 reg;
 136         u32 dtype;
 137
 138         /*
 139          * For those devices which are not connected
 140          * to the PCI Bus (e.g. LPC) there is a bar
 141          * descriptor located directly after the
 142          * chameleon header. This header is comparable
 143          * to a PCI header.
 144          */
 145         dtype = get_next_dtype(*base);
 146         if (dtype == CHAMELEON_DTYPE_BAR) {
 147                 reg = readl(*base);
 148
 149                 bar_count = BAR_CNT(reg);
 150                 if (bar_count <= 0 || bar_count > CHAMELEON_BAR_MAX)
 151                         return -ENODEV;
 152
 153                 c = kcalloc(bar_count, sizeof(struct chameleon_bar),
 154                             GFP_KERNEL);
 155                 if (!c)
 156                         return -ENOMEM;
 157
 158                 chameleon_parse_bar(*base, c, bar_count);
 159                 *base += BAR_DESC_SIZE(bar_count);
 160         } else {
 161                 c = kzalloc(sizeof(struct chameleon_bar), GFP_KERNEL);
 162                 if (!c)
 163                         return -ENOMEM;
 164
 165                 bar_count = 1;
 166                 c->addr = mapbase;
 167         }
 168
 169         *cb = c;
 170
 171         return bar_count;
 172 }
 173
 174 int chameleon_parse_cells(struct mcb_bus *bus, phys_addr_t mapbase,
 175                         void __iomem *base)
 176 {
 177         struct chameleon_fpga_header *header;
 178         struct chameleon_bar *cb;
 179         void __iomem *p = base;
 180         int num_cells = 0;
 181         uint32_t dtype;
 182         int bar_count;
 183         int ret;
 184         u32 hsize;
 185         u32 table_size;
 186
 187         hsize = sizeof(struct chameleon_fpga_header);
 188
 189         header = kzalloc(hsize, GFP_KERNEL);
 190         if (!header)
 191                 return -ENOMEM;
 192
 193         /* Extract header information */
 194         memcpy_fromio(header, p, hsize);
 195         /* We only support chameleon v2 at the moment */
 196         header->magic = le16_to_cpu(header->magic);
 197         if (header->magic != CHAMELEONV2_MAGIC) {
 198                 pr_err("Unsupported chameleon version 0x%x\n",
 199                                 header->magic);
 200                 ret = -ENODEV;
 201                 goto free_header;
 202         }
 203         p += hsize;
 204
 205         bus->revision = header->revision;
 206         bus->model = header->model;
 207         bus->minor = header->minor;
 208         snprintf(bus->name, CHAMELEON_FILENAME_LEN + 1, "%s",
 209                  header->filename);
 210
 211         bar_count = chameleon_get_bar(&p, mapbase, &cb);
 212         if (bar_count < 0) {
 213                 ret = bar_count;
 214                 goto free_header;
 215         }
 216
 217         for_each_chameleon_cell(dtype, p) {
 218                 switch (dtype) {
 219                 case CHAMELEON_DTYPE_GENERAL:
 220                         ret = chameleon_parse_gdd(bus, cb, p, bar_count);
 221                         if (ret < 0)
 222                                 goto free_bar;
 223                         p += sizeof(struct chameleon_gdd);
 224                         break;
 225                 case CHAMELEON_DTYPE_BRIDGE:
 226                         chameleon_parse_bdd(bus, cb, p);
 227                         p += sizeof(struct chameleon_bdd);
 228                         break;
 229                 case CHAMELEON_DTYPE_END:
 230                         break;
 231                 default:
 232                         pr_err("Invalid chameleon descriptor type 0x%x\n",
 233                                 dtype);
 234                         ret = -EINVAL;
 235                         goto free_bar;
 236                 }
 237                 num_cells++;
 238         }
 239
 240         if (num_cells == 0) {
 241                 ret = -EINVAL;
 242                 goto free_bar;
 243         }
 244
 245         table_size = p - base;
 246         pr_debug("%d cell(s) found. Chameleon table size: 0x%04x bytes\n", num_cells, table_size);
 247         kfree(cb);
 248         kfree(header);
 249         return table_size;
 250
 251 free_bar:
 252         kfree(cb);
 253 free_header:
 254         kfree(header);
 255
 256         return ret;
 257 }
 258 EXPORT_SYMBOL_GPL(chameleon_parse_cells);